Quickstart

Send your first crosschain intent straight through the REST API. This guide walks the full flow for EOA users.

Using the Rhinestone SDK? The wallet quickstart already covers crosschain intents. Come back here when you need API-specific configuration.Using an existing smart account (non-Rhinestone SDK)? You’ll need to install the Intent Executor on each account before using Warp, then follow the smart account signing guide for the signing step.

Prerequisites

A Rhinestone API key (request one here) — not required for testnets
An EOA with funds on Ethereum, Optimism, Base, or Arbitrum — the source chains this quickstart handles below (extend the accountAccessList and wrap map for any other supported chain)

Steps

Get a quote

Submit a meta intent to the /quotes endpoint. Specify your destination chain, the token and amount you want on that chain, and your account:

import { createWalletClient, extractChain, http, type Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import * as chains from "viem/chains";

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

// EOA signer — swap in any viem-compatible signer.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);
const EOA_ADDRESS = account.address;

// A route can pull source funds from any chain, so token requirements can land
// on any chain. Build a wallet client for whichever chain a requirement targets.
const walletClientFor = (chainId: string) =>
  createWalletClient({
    account,
    chain: extractChain({
      chains: Object.values(chains),
      id: Number(chainId.split(":")[1]),
    }),
    transport: http(),
  });

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

const res = await fetch(`${BASE_URL}/quotes`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    account: {
      address: EOA_ADDRESS,
      accountType: "EOA",
    },
    destinationChainId: "eip155:8453", // Base
    tokenRequests: [
      {
        tokenAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
        amount: "5000000", // 5 USDC (6 decimals)
      },
    ],
    // Limit source funds to the chains this quickstart handles below.
    accountAccessList: {
      chainIds: ["eip155:1", "eip155:10", "eip155:8453", "eip155:42161"],
    },
  }),
});

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

The response is a server-ranked routes array. Use routes[0] unless you have your own ranking. Each route carries:

intentId: server-stored handle, used to submit
cost: input/output amounts and fee breakdown
signData: EIP-712 typed data to sign
tokenRequirements: approvals or wrapping the user must complete before signing

Fulfill token requirements

Before signing, the user must fulfill any tokenRequirements returned in the quote. Keys are CAIP-2 chain ids (eip155:8453):ERC-20 approvals — approve tokens to the Permit2 contract:

import { erc20Abi, maxUint256 } from "viem";

for (const [chainId, tokens] of Object.entries(tokenRequirements)) {
  for (const [tokenAddress, requirement] of Object.entries(tokens)) {
    if (requirement.type === "approval") {
      await walletClientFor(chainId).writeContract({
        address: tokenAddress,
        abi: erc20Abi,
        functionName: "approve",
        args: [requirement.spender, maxUint256],
      });
    }
  }
}

ETH wrapping — wrap native ETH to WETH:

// Wrapped-native token for each chain in the accountAccessList above
// (only needed when the source token is ETH).
const WETH: Record<string, `0x${string}`> = {
  "eip155:1": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // Ethereum
  "eip155:10": "0x4200000000000000000000000000000000000006", // Optimism
  "eip155:8453": "0x4200000000000000000000000000000000000006", // Base
  "eip155:42161": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1", // Arbitrum
};
const wethAbi = [
  {
    name: "deposit",
    type: "function",
    stateMutability: "payable",
    inputs: [],
    outputs: [],
  },
] as const;

for (const [chainId, tokens] of Object.entries(tokenRequirements)) {
  for (const [tokenAddress, requirement] of Object.entries(tokens)) {
    if (requirement.type === "wrap") {
      await walletClientFor(chainId).writeContract({
        address: WETH[chainId],
        abi: wethAbi,
        functionName: "deposit",
        value: BigInt(requirement.amount),
      });
    }
  }
}

Use max approvals to the Permit2 contract. This is the only contract you ever approve — future intents won’t need a new approval.

Sign the intent

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

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

Signing guide

Smart account signing and validator wrapping.

Submit the intent

Post the signed intent to /intents:

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();

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

Poll for completion

Track execution status using the intentId:

async function pollStatus(intentId: string) {
  while (true) {
    const res = await fetch(`${BASE_URL}/intents/${intentId}`, { headers });
    const { status } = await res.json();

    if (["COMPLETED", "FAILED", "EXPIRED"].includes(status)) {
      console.log("Final status:", status);
      return status;
    }

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

await pollStatus(submittedId);

Once execution finishes you’ll see the terminal status:

Final status: COMPLETED

Typical execution time is under 2 seconds. See Tracking intents for the full lifecycle.

Your tokens moved across chains from a single set of signatures — no bridge, no manual settlement.

Next steps

Getting a Quote

Advanced quote options: sponsorship, source chain filtering, destination executions.

Token Requirements

Full details on approvals and ETH wrapping.

Error Handling

Common Orchestrator errors and how to fix them.

Tutorial

Sending intents

Use cases

API guides

Configuration

Prerequisites

Steps

Signing guide

Next steps

Getting a Quote

Token Requirements

Error Handling

​Prerequisites

​Steps

Signing guide

​Next steps

Getting a Quote

Token Requirements

Error Handling

Prerequisites

Steps

Next steps