Execute a crosschain swap

Bridge and swap tokens across chains in a single intent using the Rhinestone API.

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 } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const BASE_URL = "https://v1.orchestrator.rhinestone.dev";
const API_KEY = "YOUR_RHINESTONE_API_KEY";

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

const account = privateKeyToAccount("0xYOUR_PRIVATE_KEY");

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

const EOA_ADDRESS = account.address;

Steps

1. 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);
   
2. 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.

3. 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.

4. 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.

5. 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.