Swap and route local stablecoins with LI.FI

import type { LiFiStep } from '@lifi/types';
import { LIFI_API } from './constants';

export type QuoteParams = {
  fromChain: number;
  toChain: number;
  fromToken: string;
  toToken: string;
  fromAmount: bigint; // in the source token's smallest unit (wFiat has 18 decimals)
  fromAddress: `0x${string}`;
  toAddress?: `0x${string}`; // defaults to fromAddress
  slippage?: number; // 0.005 = 0.5%
};

export async function getQuote(p: QuoteParams): Promise<LiFiStep> {
  const params = new URLSearchParams({
    fromChain: String(p.fromChain),
    toChain: String(p.toChain),
    fromToken: p.fromToken,
    toToken: p.toToken,
    fromAmount: p.fromAmount.toString(),
    fromAddress: p.fromAddress,
    slippage: String(p.slippage ?? 0.005),
    integrator: 'your-app-name',
  });
  if (p.toAddress) params.set('toAddress', p.toAddress);

  const res = await fetch(`${LIFI_API}/quote?${params}`);
  if (!res.ok) {
    const body = await res.json().catch(() => ({ message: res.statusText }));
    throw Object.assign(new Error(body.message), body); // { code, message }, e.g. 1002 when no route is found
  }
  return res.json();
}

import { erc20Abi, zeroAddress } from 'viem';
import type { getClients } from './clients';

type Clients = ReturnType<typeof getClients>;

export async function ensureAllowance(
  { publicClient, walletClient }: Clients,
  token: `0x${string}`,
  owner: `0x${string}`,
  spender: `0x${string}`, // quote.estimate.approvalAddress
  amount: bigint,
) {
  if (token === zeroAddress) return; // native token: nothing to approve

  const allowance = await publicClient.readContract({
    address: token,
    abi: erc20Abi,
    functionName: 'allowance',
    args: [owner, spender],
  });
  if (allowance >= amount) return;

  const hash = await walletClient.writeContract({
    account: owner,
    address: token,
    abi: erc20Abi,
    functionName: 'approve',
    args: [spender, amount], // the exact amount; a larger allowance saves future approvals
  });
  const receipt = await publicClient.waitForTransactionReceipt({ hash });
  if (receipt.status !== 'success') throw new Error('Approval reverted');
}

import type { LiFiStep } from '@lifi/types';
import { getClients } from './clients';
import { ensureAllowance } from './approve';

export async function executeQuote(quote: LiFiStep, owner: `0x${string}`) {
  const tx = quote.transactionRequest!;
  const clients = getClients(tx.chainId!); // the source chain
  await clients.walletClient.switchChain({ id: tx.chainId! });

  await ensureAllowance(
    clients,
    quote.action.fromToken.address as `0x${string}`,
    owner,
    quote.estimate.approvalAddress as `0x${string}`,
    BigInt(quote.action.fromAmount),
  );

  const hash = await clients.walletClient.sendTransaction({
    account: owner,
    to: tx.to as `0x${string}`,
    data: tx.data as `0x${string}`,
    value: BigInt(tx.value ?? 0),
    gas: tx.gasLimit ? BigInt(tx.gasLimit) : undefined,
  });
  const receipt = await clients.publicClient.waitForTransactionReceipt({ hash });
  if (receipt.status !== 'success') throw new Error('Swap reverted: request a new quote');
  return hash;
}

import { LIFI_API } from './constants';

export async function waitForTransfer(txHash: string, fromChain: number, toChain: number, maxWaitMs = 30 * 60_000) {
  const startedAt = Date.now();
  let delay = 10_000;

  while (Date.now() - startedAt < maxWaitMs) {
    const params = new URLSearchParams({ txHash, fromChain: String(fromChain), toChain: String(toChain) });
    const res = await fetch(`${LIFI_API}/status?${params}`);

    if (res.ok) {
      const status = await res.json();
      if (status.status === 'DONE' || status.status === 'FAILED') return status;
      if (status.status === 'INVALID') throw new Error('The hash does not belong to this transfer');
    } else if (res.status !== 404) {
      // 404 (code 1003) is normal for the first minute or two after broadcast; anything else isn't
      throw new Error(`LI.FI status error ${res.status}`);
    }

    await new Promise((r) => setTimeout(r, delay));
    delay = Math.min(delay * 2, 60_000);
  }
  throw new Error('Transfer still pending: check it later on scan.li.fi');
}

'use client';

import { LiFiWidget, type WidgetConfig } from '@lifi/widget';

const config: WidgetConfig = {
  toChain: 8453, // Base
  toToken: '0x0DC4F92879B7670e5f4e4e6e3c801D229129D90D', // wARS
  tokens: {
    include: [
      { chainId: 8453, address: '0xD76f5Faf6888e24D9F04Bf92a0c8B921FE4390e0', symbol: 'wBRL', decimals: 18, name: 'wBRL' },
      { chainId: 8453, address: '0x337E7456B420bD3481e7FA61fA9850343d610d34', symbol: 'wMXN', decimals: 18, name: 'wMXN' },
    ],
  },
};

export function SwapWidget() {
  return <LiFiWidget integrator="your-app-name" config={config} />;
}