Examples

import { createPublicClient, createWalletClient, http, parseUnits } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';

const API_BASE = 'https://api.superbridge.app';
const API_KEY = 'your-api-key';

const account = privateKeyToAccount('0x...');

const publicClient = createPublicClient({
  chain: mainnet,
  transport: http(),
});

const walletClient = createWalletClient({
  account,
  chain: mainnet,
  transport: http(),
});

// 1. Get a route
const routesResponse = await fetch(`${API_BASE}/v1/routes`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': API_KEY,
  },
  body: JSON.stringify({
    fromChainKey: 'eth',
    toChainKey: 'base',
    fromTokenAddress: '0x0000000000000000000000000000000000000000',
    toTokenAddress: '0x0000000000000000000000000000000000000000',
    amount: parseUnits('0.01', 18).toString(),
    sender: account.address,
    recipient: account.address,
  }),
});

const { results } = await routesResponse.json();

// 2. Pick the first quote (check for initiatingTransaction to distinguish from errors)
const quote = results.find((r) => r.result.initiatingTransaction)?.result;
if (!quote) throw new Error('No quote available');

// 3. Send the initiating transaction
const hash = await walletClient.sendTransaction({
  to: quote.initiatingTransaction.to,
  data: quote.initiatingTransaction.data,
  value: BigInt(quote.initiatingTransaction.value),
});

console.log('Transaction sent:', hash);

// 4. Wait for the transaction to be confirmed
await publicClient.waitForTransactionReceipt({ hash });

// 5. Poll activity until the bridge is complete
async function pollUntilComplete() {
  while (true) {
    const activityResponse = await fetch(
      `${API_BASE}/v1/activity?evmAddress=${account.address}`,
      { headers: { 'x-api-key': API_KEY } },
    );
    const activities = await activityResponse.json();

    // Find our bridge by matching the initiating tx hash
    const bridge = activities.find((a) =>
      a.steps.some(
        (s) =>
          s.type === 'transaction' &&
          s.transactionType === 'done' &&
          s.confirmation?.transactionHash === hash,
      ),
    );

    if (!bridge) {
      // Transaction not indexed yet, wait and retry
      await new Promise((r) => setTimeout(r, 5000));
      continue;
    }

    // Check if all steps are done
    const allDone = bridge.steps.every((s) =>
      s.type === 'transaction'
        ? s.transactionType === 'done' || s.transactionType === 'auto'
        : s.type === 'wait'
          ? s.waitType === 'done'
          : true,
    );

    if (allDone) {
      console.log('Bridge complete!');
      return bridge;
    }

    // Check for a step that needs signing
    const readyStep = bridge.steps.find(
      (s) => s.type === 'transaction' && s.transactionType === 'ready',
    );

    if (readyStep) {
      // Get the step transaction data
      const stepTxResponse = await fetch(
        `${API_BASE}/v1/get_step_transaction`,
        {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-api-key': API_KEY,
          },
          body: JSON.stringify({
            id: bridge.id,
            action: readyStep.action,
            provider: bridge.provider.name,
            submitter: account.address,
          }),
        },
      );
      const stepTx = await stepTxResponse.json();

      const stepHash = await walletClient.sendTransaction({
        to: stepTx.to,
        data: stepTx.data,
        value: BigInt(stepTx.value),
      });
      await publicClient.waitForTransactionReceipt({ hash: stepHash });
      console.log('Step transaction sent:', stepHash);
    }

    // Wait using nextCheckTimestamp
    const delay = bridge.nextCheckTimestamp
      ? Math.max(bridge.nextCheckTimestamp - Date.now(), 2000)
      : 5000;
    await new Promise((r) => setTimeout(r, delay));
  }
}

await pollUntilComplete();

// After getting a quote...

// Check if token approval is needed
if (quote.tokenApproval) {
  // Some tokens (e.g. USDT) require revoking existing allowance first
  if (quote.revokeTokenApproval) {
    const revokeHash = await walletClient.sendTransaction({
      to: quote.revokeTokenApproval.tx.to,
      data: quote.revokeTokenApproval.tx.data,
    });
    await publicClient.waitForTransactionReceipt({ hash: revokeHash });
  }

  const approveHash = await walletClient.sendTransaction({
    to: quote.tokenApproval.tx.to,
    data: quote.tokenApproval.tx.data,
  });
  await publicClient.waitForTransactionReceipt({ hash: approveHash });
}

// Check if gas token approval is needed (custom gas token rollups)
if (quote.gasTokenApproval) {
  const gasApproveHash = await walletClient.sendTransaction({
    to: quote.gasTokenApproval.tx.to,
    data: quote.gasTokenApproval.tx.data,
  });
  await publicClient.waitForTransactionReceipt({ hash: gasApproveHash });
}

// Now send the initiating transaction
const hash = await walletClient.sendTransaction({
  to: quote.initiatingTransaction.to,
  data: quote.initiatingTransaction.data,
  value: BigInt(quote.initiatingTransaction.value),
});