Relay a transaction - Rhinestone

Relay one or more contract calls on a single chain. Use Send a transaction instead when the transaction must source funds from another chain or deliver tokens to the target chain.

Define the calls

This example transfers 0.1 USDC from the account on Base Sepolia. Both wallet types use the same calldata. Calls run in order and revert together if one fails.

import { encodeFunctionData, erc20Abi, parseUnits } from "viem";
import { baseSepolia } from "viem/chains";

const usdc = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
const recipient = "0xd8da6bf26964af9d7eed9e03e53415d37aa96045";
const amount = parseUnits("0.1", 6);

const calls = [
  {
    to: usdc,
    value: 0n,
    data: encodeFunctionData({
      abi: erc20Abi,
      functionName: "transfer",
      args: [recipient, amount],
    }),
  },
] as const;

Send the transaction

Embedded wallet
Custom signer

Use oneAuth and the authenticated accountAddress from Accounts. These options are available in @rhinestone/1auth 0.10.1.sendIntent() prepares the route, requests passkey approval, and submits the transaction. Set sourceChainId and targetChain to the same chain to keep funding and execution on Base Sepolia:

import { oneAuth } from "./oneauth";

const result = await oneAuth.sendIntent({
  accountAddress,
  targetChain: baseSepolia.id,
  sourceChainId: baseSepolia.id,
  sourceAssets: [usdc],
  calls: [...calls],
  sponsorshipMode: "required",
  experimental_clear_signing: true,
  closeOn: "completed",
  waitForHash: true,
});

if (!result.success) {
  throw new Error(result.error?.message ?? `Intent ended as ${result.status}`);
}

console.log(result.intentId, result.status, result.transactionHash);

experimental_clear_signing: true shows Rhinestone’s prepared-action review before passkey approval. By default, your application owns the review UI. See Clear signing for the experimental review contract.closeOn: "completed" waits for completion rather than an earlier execution milestone. waitForHash: true also requests the onchain transaction hash. If a request times out, keep any returned intentId and check it with oneAuth.getIntentStatus(intentId) before sending again. Inspect status: a pending status is not a failed transaction, even when that status response has success: false.

Choose who pays

This example uses sponsorshipMode: "required": sponsorship must succeed or the request fails. Set it to "disabled" for a user-paid quote, with enough USDC on Base Sepolia to cover fees as well as the transfer.Embedded wallets do not expose ranked quotes or per-category sponsorship controls through sendIntent(). See Sponsor fees for funding modes and fallback behavior.

Try atomic calls

This sponsored testnet demo uses the embedded wallet provider’s wallet_sendCalls to relay two 0.1 mUSD transfers on Base Sepolia. Sign in, mint mock tokens if needed, then approve both calls together. Unlike a queue of intents, these calls execute in one transaction and revert together.A calls ID identifies the submission, not its outcome. Use Check status to inspect the receipts: 0x1 means success and 0x0 means failure, even when the overall status is CONFIRMED.

Use account from the Custom signer quickstart with @rhinestone/sdk@2.16.1. There is no separate relayTransaction SDK method: use prepareTransaction, signTransaction, and submitTransaction with chain to request a same-chain route.

Prepare a same-chain route

const prepared = await account.prepareTransaction({
  chain: baseSepolia,
  calls: [...calls],
});

const quote = prepared.quotes.best;
console.log(quote.cost.input, quote.cost.output, quote.cost.fees);

prepareTransaction returns ranked intent routes. Review the recommended route’s assets, fees, and expiry before requesting a signature. To select another route, pass its intentId to signTransaction; never combine a signature from one route with another route.

Sign and submit

import { isExecutionError } from "@rhinestone/sdk/errors";

const signed = await account.signTransaction(prepared, {
  intentId: quote.intentId,
});
const submitted = await account.submitTransaction(signed);

try {
  const result = await account.waitForExecution(submitted);
  console.log(result.status, result.operations);
} catch (error) {
  if (error instanceof Error && isExecutionError(error)) {
    console.error(error.message, error.traceId, error.context);
  }
  throw error;
}

submitTransaction returns after the orchestrator accepts the intent. That acceptance is not an onchain success. Keep the returned intent ID and call waitForExecution or query its status until it reaches a terminal outcome. Status queries can return PENDING; waitForExecution waits for a terminal result or throws.

Outcome	Meaning
`PENDING`	The intent was accepted and its same-chain operation is still processing.
`COMPLETED`	The operation was confirmed. Its entry includes the onchain transaction hash.
`FAILED`	Execution failed. `waitForExecution` throws an execution error whose context includes the operation and failure reason.

If submission returns an uncertain network result, query the existing intent before preparing another one to avoid duplicate execution. If the quote expires before submission, prepare and sign a new route.

Choose who pays

The example above is user-paid, so the account also needs enough funds to cover the quoted fees. To sponsor execution, set sponsored: true during preparation:

const prepared = await account.prepareTransaction({
  chain: baseSepolia,
  calls: [...calls],
  sponsored: true,
});

Only fee categories present in the selected route are charged. Sponsorship is decided while quoting; a rejected sponsored request does not silently become user-paid. Follow Sponsor fees for selective categories, quote inspection, and fallback behavior.

Restrict the fee asset

sourceAssets is the list of balances the orchestrator may spend. In a call-only relay the only balance it spends is the fee repayment, so this pins which token pays:

const prepared = await account.prepareTransaction({
  chain: baseSepolia,
  calls: [...calls],
  sourceAssets: [usdc],
});

Use the native token’s zero address to allow the account’s native balance. A user-paid request fails at quote time when none of the named assets can cover the fee.

Set the destination gas limit

gasLimit is the gas the calls are quoted against. Without it, the quote assumes a conservative default of 1,000,000 units, so a small call is over-quoted:

const prepared = await account.prepareTransaction({
  chain: baseSepolia,
  calls: [...calls],
  gasLimit: 200_000n,
});

Estimate the calls and add headroom. A limit below actual usage makes execution run out of gas.

Extend the fill deadline

Same-chain routes carry a two-minute onchain fill deadline. customDeadline overrides it with an absolute Unix timestamp in seconds, which is useful when a user reviews the action before approving:

const prepared = await account.prepareTransaction({
  chain: baseSepolia,
  calls: [...calls],
  customDeadline: Math.floor(Date.now() / 1000) + 900,
});

The value must be between two minutes and 24 hours from now; anything outside that range is rejected while quoting. The quoted expiresAt tracks it. This option is same-chain only — crosschain routes cannot set it.

Declare incoming funds

auxiliaryFunds lets the route count a balance that has not landed yet but arrives before settlement. It works the same way here as for multichain transactions; see Quote against incoming funds.

Other account types

The same prepare, sign, and submit contract supports plain EOAs, EIP-7702 accounts, and the SDK’s Nexus, Safe, Kernel, Startale, and HCA smart account providers. This guide uses the default Nexus account from the quickstart. A pre-signed native Safe transaction uses the separate Safe relay flow: see Relay a Safe transaction.For an EIP-7702 account, include its initialization signature while preparing and submit the resulting authorizations. Follow the EIP-7702 transaction flow.

Recovery guardians cannot sign an intent. Use account owners or a compatible session key for this flow; guardians authorize recovery UserOperations only.

​Define the calls

​Send the transaction

​Choose who pays

​Try atomic calls

​Prepare a same-chain route

​Sign and submit

​Choose who pays

​Restrict the fee asset

​Set the destination gas limit

​Extend the fill deadline

​Declare incoming funds

​Other account types

Define the calls

Send the transaction

Choose who pays

Try atomic calls

Prepare a same-chain route

Sign and submit

Choose who pays

Restrict the fee asset

Set the destination gas limit

Extend the fill deadline

Declare incoming funds

Other account types