Execute a crosschain swap

In this tutorial you will swap USDC on Base for ETH on Arbitrum in a single intent. Warp handles the bridge and swap automatically — one signature, one operation, one confirmation. By the end you will have a working end-to-end implementation you can adapt for any crosschain swap.

Prerequisites

A Rhinestone API key (request one here)
An EOA with USDC on Base (or another supported chain and token)
A viem WalletClient configured for signing

Setup

import { createWalletClient, http, erc20Abi, maxUint256, type Hex } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const BASE_URL = "https://v1.orchestrator.rhinestone.dev";
const API_KEY = process.env.RHINESTONE_API_KEY;

const headers = {
  "Content-Type": "application/json",
  "x-api-key": API_KEY,
  "x-api-version": "2026-04.blanc",
};

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

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

const EOA_ADDRESS = account.address;

Steps

Get a quote

Request a quote for swapping USDC on Base into ETH on Arbitrum. Specify the destination chain, the token you want, and the amount:

const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const ETH_ARBITRUM = "0x0000000000000000000000000000000000000000"; // native ETH
const ETH_AMOUNT = "10000000000000000"; // 0.01 ETH (18 decimals)

const quoteRes = await fetch(`${BASE_URL}/quotes`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    account: {
      address: EOA_ADDRESS,
      accountType: "EOA",
    },
    destinationChainId: "eip155:42161", // Arbitrum
    tokenRequests: [
      {
        tokenAddress: ETH_ARBITRUM,
        amount: ETH_AMOUNT,
      },
    ],
    accountAccessList: {
      chainTokens: {
        "eip155:8453": [USDC_BASE], // Base
      },
    },
  }),
});

const { routes } = await quoteRes.json();
const route = routes[0];
const { intentId, cost, signData, tokenRequirements } = route;

accountAccessList constrains which tokens on which chains the router can spend. Without it, the API may route through multiple chains and tokens (including wrapped ETH), which can lead to unexpected gas requirements. Specify the exact source token(s) you want to use.

Because the source token (USDC on Base) differs from the destination token (ETH on Arbitrum), cost.input and cost.output show different tokens. This is how you know Warp is routing through a swap.

console.log("Spending:", cost.input);
console.log("Receiving:", cost.output);

Approve token spending

Check tokenRequirements for any approvals needed. For a USDC source, you will typically need a Permit2 approval:

if (tokenRequirements) {
  for (const [chainId, tokens] of Object.entries(tokenRequirements)) {
    for (const [tokenAddress, requirement] of Object.entries(tokens as Record<string, any>)) {
      if (requirement.type === "approval") {
        console.log(`Approving ${tokenAddress} on ${chainId}...`);

        const { request } = await walletClient.simulateContract({
          address: tokenAddress as `0x${string}`,
          abi: erc20Abi,
          functionName: "approve",
          args: [requirement.spender, maxUint256],
        });

        const hash = await walletClient.writeContract(request);
        console.log("Approval tx:", hash);
      }
    }
  }
}

This approves to the Permit2 contract. Once approved, future intents spending the same token on the same chain will not need another approval.

Sign the intent

Forward signData.origin[] and signData.destination directly to your wallet. One signature per source chain, plus the destination signature.

const originSignatures = await Promise.all(
  signData.origin.map((typedData) =>
    walletClient.signTypedData(typedData),
  ),
);
const destinationSignature = await walletClient.signTypedData(
  signData.destination,
);

Signing guide

Smart account signing and validator wrapping.

Submit the intent

Post the signed intent to /intents using the intentId from the quote:

const submitRes = await fetch(`${BASE_URL}/intents`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    intentId,
    signatures: {
      origin: originSignatures,
      destination: destinationSignature,
    },
  }),
});

const { intentId: submittedId } = await submitRes.json();

console.log("Intent submitted:", submittedId);

If the submit returns 404, the quote TTL elapsed — re-quote and re-sign.

Poll for completion

Track the intent status until it reaches a final state:

async function pollUntilComplete(intentId: string) {
  const FINAL_STATUSES = ["COMPLETED", "FAILED", "EXPIRED"];

  while (true) {
    const res = await fetch(`${BASE_URL}/intents/${intentId}`, { headers });

    const data = await res.json();
    console.log("Status:", data.status);

    if (FINAL_STATUSES.includes(data.status)) {
      if (data.status === "COMPLETED") {
        console.log("Swap complete!");
        console.log("Fill tx:", data.fillTransactionHash);
      } else {
        console.error("Intent failed with status:", data.status);
      }
      return data.status;
    }

    await new Promise((resolve) => setTimeout(resolve, 2000));
  }
}

await pollUntilComplete(submittedId);

Typical execution time is under 2 seconds. FILLED is an intermediate state — the relayer has delivered funds on the destination, but the source-chain claim hasn’t settled yet. COMPLETED means everything is settled.

Next steps

Sponsor fees

Cover bridge and swap fees for your users using sponsorSettings.

Execute crosschain calls

Add destination chain executions to your intent — deposit into a vault, buy an NFT, and more.

Tutorial

Sending intents

Use cases

API guides

Configuration

Execute a crosschain swap

Prerequisites

Setup

Steps

Signing guide

Next steps

Sponsor fees

Execute crosschain calls

​Prerequisites

​Setup

​Steps

Signing guide

​Next steps

Sponsor fees

Execute crosschain calls

Prerequisites

Setup

Steps

Next steps