Pay cross-chain

import { createComposeSdk, materialisers, raw, resources } from '@lifi/composer-sdk';
import { privateKeyToAccount } from 'viem/accounts';
import type { Hex } from 'viem';

const ARBITRUM = 42161;
const BASE = 8453;
const ARB_USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';

const sdk = createComposeSdk({ baseUrl: 'https://composer.li.quest', apiKey: process.env.LIFI_API_KEY! });
const owner = privateKeyToAccount(process.env.PRIVATE_KEY as Hex).address;

// The payment: 990 USDC to the payee plus a 10 USDC fee (6 decimals).
const payment = {
  payee: '0x1111111111111111111111111111111111111111',
  amount: 990_000_000n,
  feeRecipient: '0x2222222222222222222222222222222222222222',
  fee: 10_000_000n,
};
const total = payment.amount + payment.fee; // 1,000 USDC

// 1. Destination flow, on Base: take exactly the total, then split it in two.
//    Splitting the total first keeps both amounts exact: anything extra sent
//    to the escrow stays out of the payment and goes to the refund address.
//    In production, replace the two transfers with one core.call to your
//    payment contract.
const destFlow = sdk.flow(BASE, {
  name: 'pay-on-base',
  inputs: { funding: resources.erc20(BASE_USDC, BASE) },
});
const { head: payable } = destFlow.core.splitAt('total', {
  bind: { source: destFlow.inputs.funding },
  config: { amount: `${total}` },
});
const { head: toPayee, tail: toFee } = destFlow.core.splitAt('split', {
  bind: { source: payable },
  config: { amount: `${payment.amount}` },
});
destFlow.core.transfer('payPayee', {
  bind: { amount: toPayee, recipient: raw.literal('address', payment.payee) },
  config: {},
});
destFlow.core.transfer('payFee', {
  bind: { amount: toFee, recipient: raw.literal('address', payment.feeRecipient) },
  config: {},
});

// 2. Source flow, on Arbitrum: swap ETH to USDC, then open an Intents order
//    that delivers exactly 1,000 USDC into the escrow on Base.
const source = sdk.flow(ARBITRUM, {
  name: 'pay-from-arbitrum',
  inputs: { eth: resources.native(ARBITRUM) },
});
const swap = source.lifi.swap('swap', {
  bind: { amountIn: source.inputs.eth },
  config: { resourceOut: resources.erc20(ARB_USDC, ARBITRUM), slippage: 0.005 },
});
const order = source.lifiIntents.order('order', {
  bind: { amountIn: swap.amountOut },
  config: { resourceOut: resources.erc20(BASE_USDC, BASE), exactAmountOut: `${total}` },
});
source.continuation.settle('settle', {
  bind: { input: order.amountOut },
  config: {
    exact: true,   // the escrow commits to these exact transfers
    outcomes: [],  // everything is paid out; nothing comes back on Base
    continuationFlow: destFlow.build(),
    validity: { expiresAtMs: Date.now() + 60 * 60 * 1000 },
    refund: owner,
  },
});

// 3. Compile. Payments leave the flow, so turn off the price-impact check.
const result = await source.compile({
  signer: owner,
  inputs: { eth: materialisers.directDeposit({ amount: '500000000000000000' }) }, // 0.5 ETH
  sweepTo: owner, // unspent Arbitrum USDC returns in the same transaction
  maxPriceImpactBps: 0,
});

// 4. Submit result.actions on Arbitrum (same loop as every guide), then track the escrow.

LIFI_API_KEY=... PRIVATE_KEY=0x... npx tsx pay-cross-chain.mts