Examples

import { createClient, routeGuards, txGuards, activityStepGuards } from "@superbridge/sdk";
import { createPublicClient, createWalletClient, http, parseUnits } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";

const sb = createClient({ apiKey: "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 routes = await sb.getRoutes({
  fromChainKey: "eth",
  toChainKey: "base",
  fromTokenAddress: "0x0000000000000000000000000000000000000000",
  toTokenAddress: "0x0000000000000000000000000000000000000000",
  amount: parseUnits("0.01", 18).toString(),
  sender: account.address,
  recipient: account.address,
});

// 2. Find the first quote using SDK type guards
const quote = routes.results
  .map((r) => r.result)
  .find(routeGuards.isRouteQuote);
if (!quote) throw new Error("No quote available");

// 3. Narrow and send the initiating transaction
const { initiatingTransaction } = quote;
if (!txGuards.isEvmTx(initiatingTransaction)) {
  throw new Error("Expected an EVM transaction");
}

const hash = await walletClient.sendTransaction({
  to: initiatingTransaction.to,
  data: initiatingTransaction.data,
  value: BigInt(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 activities = await sb.getActivity({
      evmAddress: account.address,
    });

    // Find our bridge by matching the initiating tx hash
    const bridge = activities.find((a) =>
      a.steps.some(
        (s) =>
          activityStepGuards.isTransactionStepDone(s) &&
          s.confirmation?.transactionHash === hash
      )
    );

    if (!bridge) {
      await new Promise((r) => setTimeout(r, 5000));
      continue;
    }

    // Check if all steps are done
    const allDone = bridge.steps.every(
      (s) =>
        activityStepGuards.isTransactionStepDone(s) ||
        activityStepGuards.isTransactionStepAuto(s) ||
        activityStepGuards.isWaitStepDone(s) ||
        activityStepGuards.isInfoStep(s)
    );

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

    // Check for a step that needs signing
    const readyStep = bridge.steps.find(
      activityStepGuards.isTransactionStepReady
    );

    if (readyStep) {
      // SDK doesn't have getStepTransaction yet, use fetch
      const stepTxResponse = await fetch(
        "https://api.superbridge.app/v1/get_step_transaction",
        {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "x-api-key": "your-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();

import { createClient, routeGuards } from "@superbridge/sdk";

const sb = createClient({ apiKey: "your-api-key" });

// After getting routes and finding a quote...
const quote = routes.results
  .map((r) => r.result)
  .find(routeGuards.isRouteQuote);

// 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),
});