Bridge and deposit with one signature

import {
  createComposeSdk,
  guards,
  materialisers,
  resources,
} from '@lifi/composer-sdk';
import { createPublicClient, createWalletClient, http, type Address, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { arbitrum } from 'viem/chains';
import { setTimeout as sleep } from 'node:timers/promises';

const ARBITRUM = 42161;
const BASE = 8453;
const ARB_USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const BASE_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
// Aave V3 aToken for USDC on Base
const A_BAS_USDC = '0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB';

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

const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const owner = account.address;

// 1. The destination flow: runs later on Base, from the escrow, once the
//    bridged USDC lands. The zap deposits the USDC into Aave. The aBasUSDC
//    stays in the destination flow's proxy; the settlement forwards it to
//    the outcome's destination.
const destFlow = sdk.flow(BASE, {
  name: 'deposit-on-base',
  inputs: { funding: resources.erc20(BASE_USDC, BASE) },
});
destFlow.lifi.zap('deposit', {
  bind: { amountIn: destFlow.inputs.funding },
  config: { resourceOut: resources.erc20(A_BAS_USDC, BASE) },
  // The guard proves the minimum received that the compiler commits.
  guards: [guards.slippage({ port: 'amountOut', bps: 50 })],
});

// 2. The source flow: runs now, on Arbitrum, inside the user's transaction.
const source = sdk.flow(ARBITRUM, {
  name: 'bridge-and-deposit',
  inputs: { amountIn: resources.erc20(ARB_USDC, ARBITRUM) },
});
const bridge = source.lifi.bridge('bridge', {
  bind: { amountIn: source.inputs.amountIn },
  // No `destination`: the bridge delivers into the settle node's escrow on Base.
  config: { resourceOut: resources.erc20(BASE_USDC, BASE) },
});
source.continuation.settle('settle', {
  bind: { input: bridge.amountOut }, // funded by the bridge: omit `funding`
  config: {
    outcomes: [{ token: A_BAS_USDC, destination: owner, chainId: BASE }],
    continuationFlow: destFlow.build(),
    // At least max(3 × the bridge's ETA, 30 minutes) away.
    validity: { expiresAtMs: Date.now() + 60 * 60 * 1000 },
    // Receives the escrow's balance if the destination flow doesn't run.
    // Must be an address you control on Base.
    refund: owner,
  },
});

// 3. Compile.
const result = await source.compile({
  signer: owner,
  inputs: {
    amountIn: materialisers.directDeposit({ amount: '1000000000' }), // 1,000 USDC
  },
  // Returns anything the source flow leaves on the proxy, such as the bridge's unspentIn.
  sweepTo: source.context.sender,
});
if (result.status !== 'success') {
  // Never fund an escrow from a partial response.
  throw new Error(`${result.error.kind}: ${result.error.message}`);
}

const escrow = result.settlements?.settle?.escrow;
if (escrow === undefined) throw new Error('no escrow was registered');
const outcome = result.outputs['settle.output'];
console.log('escrow', escrow.address, 'on chain', escrow.chainId);
console.log('minimum received', outcome?.amount.minimum?.value);
console.log('expected outcome', outcome?.amount.estimate?.value);

// 4. Submit the actions in order: approvals, then `execute`. All on Arbitrum.
if (result.fill?.validUntilMs !== undefined && Date.now() > result.fill.validUntilMs) {
  throw new Error('quote expired: compile again');
}
const wallet = createWalletClient({ account, chain: arbitrum, transport: http() });
const publicClient = createPublicClient({ chain: arbitrum, transport: http() });
let sourceTxHash: Hex | undefined;
for (const action of result.actions ?? []) {
  if (action.kind !== 'transaction') continue;
  const tx = action.transactionRequest;
  const hash = await wallet.sendTransaction({
    to: tx.to as Address,
    data: tx.data as Hex,
    value: BigInt(tx.value),
    gas: tx.gasLimit === undefined ? undefined : BigInt(tx.gasLimit),
  });
  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  if (receipt.status !== 'success') throw new Error(`${action.purpose} reverted`);
  if (action.purpose === 'execute') sourceTxHash = hash;
}
if (sourceTxHash === undefined) throw new Error('no execute action');

// 5. Track the bridge (LI.FI) and the escrow (Composer) until the escrow is final.
// COMPLETED and REFUNDED are final. REFUND_FAILED is retried automatically a
// limited number of times, so it needs attention only if it persists.
// An escrow that was never funded stays EXPIRED. The settlement service keeps
// checking it for about an hour (six checks, ten minutes apart), so stop with a
// margin past that.
const FINAL = ['COMPLETED', 'REFUNDED'];
const NEVER_FUNDED_AFTER_MS = 90 * 60 * 1000;
const REFUND_RETRY_WAIT_MS = 30 * 60 * 1000;
let refundFailedSince: number | undefined;

async function bridgeStatus(txHash: Hex): Promise<string> {
  const query = new URLSearchParams({
    txHash,
    fromChain: String(ARBITRUM),
    toChain: String(BASE),
  });
  const res = await fetch(`https://li.quest/v1/status?${query}`, {
    headers: { 'x-lifi-api-key': process.env.LIFI_API_KEY! },
  });
  if (!res.ok) return 'NOT_FOUND'; // LI.FI indexes the transfer shortly after mining
  const body = (await res.json()) as { status?: string };
  return body.status ?? 'NOT_FOUND';
}

async function escrowStatus(chainId: number, address: string): Promise<string> {
  const query = new URLSearchParams({
    chainId: String(chainId),
    address: address.toLowerCase(),
  });
  const res = await fetch(`https://composer.li.quest/intent-factory/status?${query}`, {
    headers: { 'x-lifi-api-key': process.env.LIFI_API_KEY! },
  });
  if (!res.ok) return `HTTP_${res.status}`;
  const body = (await res.json()) as { data: { status: string } };
  return body.data.status;
}

for (;;) {
  const [bridgeState, escrowState] = await Promise.all([
    bridgeStatus(sourceTxHash),
    escrowStatus(escrow.chainId, escrow.address),
  ]);
  console.log(`bridge: ${bridgeState}  escrow: ${escrowState}`);
  if (FINAL.includes(escrowState)) break;
  if (escrowState === 'REFUND_FAILED') {
    refundFailedSince ??= Date.now();
    if (Date.now() - refundFailedSince > REFUND_RETRY_WAIT_MS) break; // contact LI.FI support
  } else {
    refundFailedSince = undefined;
  }
  if (bridgeState === 'FAILED') break; // the escrow never receives funds
  if (escrowState === 'EXPIRED' && Date.now() > escrow.expiresAtMs + NEVER_FUNDED_AFTER_MS) break; // never funded
  await sleep(10_000);
}

LIFI_API_KEY=... PRIVATE_KEY=0x... npx tsx bridge-and-deposit.mts