端到端交易示例

import axios from 'axios';
import {
  createPublicClient,
  createWalletClient,
  erc20Abi,
  http,
  zeroAddress,
  type Address,
  type Hex,
} from 'viem';
import { mnemonicToAccount } from 'viem/accounts';
import { arbitrum } from 'viem/chains';

const API_URL = 'https://li.quest/v1';

// Get a quote for your desired transfer
const getQuote = async (
  fromChain: number,
  toChain: number,
  fromToken: string,
  toToken: string,
  fromAmount: string,
  fromAddress: string,
) => {
  const result = await axios.get(`${API_URL}/quote`, {
    params: {
      fromChain,
      toChain,
      fromToken,
      toToken,
      fromAmount,
      fromAddress,
    },
  });
  return result.data;
};

// Check the status of your transfer
const getStatus = async (
  bridge: string,
  fromChain: number,
  toChain: number,
  txHash: string,
) => {
  const result = await axios.get(`${API_URL}/status`, {
    params: {
      bridge,
      fromChain,
      toChain,
      txHash,
    },
  });
  return result.data;
};

const fromChain: number = 42161; // Arbitrum
const fromToken = 'USDC';
const toChain: number = 100; // Gnosis
const toToken = 'USDC';
const fromAmount = '1000000';

// Set up your wallet on the source chain
const account = mnemonicToAccount('YOUR_PERSONAL_MNEMONIC');
const publicClient = createPublicClient({ chain: arbitrum, transport: http() });
const walletClient = createWalletClient({ account, chain: arbitrum, transport: http() });

// Get the current allowance and update it if needed
const checkAndSetAllowance = async (
  tokenAddress: Address,
  approvalAddress: Address,
  amount: bigint,
) => {
  // Transactions with the native token don't need approval
  if (tokenAddress === zeroAddress) {
    return;
  }

  const allowance = await publicClient.readContract({
    address: tokenAddress,
    abi: erc20Abi,
    functionName: 'allowance',
    args: [account.address, approvalAddress],
  });

  if (allowance < amount) {
    const approveHash = await walletClient.writeContract({
      address: tokenAddress,
      abi: erc20Abi,
      functionName: 'approve',
      args: [approvalAddress, amount],
    });
    await publicClient.waitForTransactionReceipt({ hash: approveHash });
  }
};

const run = async () => {
  const quote = await getQuote(
    fromChain,
    toChain,
    fromToken,
    toToken,
    fromAmount,
    account.address,
  );

  await checkAndSetAllowance(
    quote.action.fromToken.address as Address,
    quote.estimate.approvalAddress as Address,
    BigInt(fromAmount),
  );

  const hash = await walletClient.sendTransaction({
    to: quote.transactionRequest.to as Address,
    data: quote.transactionRequest.data as Hex,
    value: BigInt(quote.transactionRequest.value),
    gas: BigInt(quote.transactionRequest.gasLimit),
    gasPrice: BigInt(quote.transactionRequest.gasPrice),
  });

  await publicClient.waitForTransactionReceipt({ hash });

  // Only needed for cross chain transfers
  if (fromChain !== toChain) {
    let result;
    do {
      result = await getStatus(quote.tool, fromChain, toChain, hash);

      if (result.status !== 'DONE' && result.status !== 'FAILED') {
        await new Promise((resolve) => setTimeout(resolve, 5000)); // Wait 5s
      }
    } while (result.status !== 'DONE' && result.status !== 'FAILED');
  }
};

run().then(() => {
  console.log('DONE!');
});