Quotes and checks

A quote request

const quote = await client.getQuote({
  sourceChain: "eip155-8888",
  sourceAsset: "wctm", // a catalog key, or "<chainDomain>:<address>" for a token the catalog does not list
  destChain: "solana-localnet",
  destAsset: "spl",
  amount: "500000000000000000000", // base units, a decimal string
  sourceAccount: "0x…", // who pays
  recipient: "4vUS…", // who is paid, in the destination chain's format
});

Field	Meaning
`sourceChain`, `destChain`	chain domains from the catalog (`eip155-1`, `solana-localnet`…)
`sourceAsset`, `destAsset`	a catalog asset key, or `<chainDomain>:<address>` for any token by address (the token-in lane, a launchpad token as destination). A bare `0x…` is refused
`amount`	base units, as a decimal string, never a number. What the user spends, or with `exact-output`, what the recipient receives
`sourceAccount`	the paying account. Always send it: without it the hub quotes the recipient as the payer
`recipient`	the paid account, in the destination chain’s address format
`swapType`	`exact-input` (default) or `exact-output`
`maxAmountIn`	`exact-output` only: the most the user will pay
`slippageBps`	the token-in lane only: how far the swap may spend above the quote (1–1000)

getQuote, previewQuotes and prepareQuote check both accounts before any call. A recipient that cannot be an address on destChain, or a sourceAccount that cannot be one on sourceChain, throws an InteropError (invalid-input) naming the field and the chain, for example recipient must be a Solana address (base58, or 0x and 64 hex digits) on solana-localnet. An EVM account is 0x and 40 hex digits (any casing); a Solana account is base58, or 0x and 64 hex digits. Without the check the hub answers EIN0001, with the field as its reference. A common cause: an address typed for one destination, still in the form after the user switched the destination chain. toBaseUnits("0.05", 18) and formatUnits(50000000000000000n, 18) convert between readable and base-unit amounts.

The quote

getQuote returns a Quote:

Field	Meaning
`lane`	what executing it involves: see Lanes
`payAmount`	what the user pays, in the source asset. A ceiling when `payAmountIsCeiling` (token-in)
`amountOut`	what the recipient receives. On an auction this is the floor: fills usually pay more
`quoteId`, `quoteRequestId`	the winning quote and its round
`firstReceivedAt`, `validityMs`	when this quote was first received (client clock), and how long it lives
`requestId`	the answer’s request id, for support
`request`, `response`	what was asked, and the hub’s answer unchanged

How long a quote lives

A quote lives about 30 seconds. The hub also answers an identical request within that window with the same quote and its original expiry. The SDK therefore anchors the countdown on when a quoteId was first received, using the client’s own clock only:

import { quoteTimeLeftMs } from "@c8ntinuum/infinity-interop-sdk";

const secondsLeft = Math.floor(quoteTimeLeftMs(quote) / 1000);

executeQuote wants at least 15 s left before it asks the user to sign (minSigningTimeMs). With less, it fetches a fresh quote for the same request, and continues only if the new one is not worse: the same lane, no lower output, no higher cost. A worse one throws ReviewRequiredError carrying both quotes, so you can show the new terms and ask again. Pass acceptRequote(fresh, reviewed) to decide yourself.

Reverse quotes

With swapType: "exact-output", amount is what the recipient must receive, and the quote’s payAmount is the price:

const quote = await client.getQuote({
  sourceChain: "eip155-1", sourceAsset: "eth",
  destChain: "eip155-8888", destAsset: "ctm",
  amount: "100000000000000000000", // exactly 100 CTM to the recipient
  swapType: "exact-output",
  maxAmountIn: "10000000000000000", // optional: pay at most 0.01 ETH
  sourceAccount: me, recipient: me,
});

A maxAmountIn under the price answers EIN0008 providerRefused: raise the cap rather than retry. The token-in lane refuses exact-output (EIN0001, reference swapType).

Preview and prepare

For a UI that shows live estimates as the user types, then commits to one provider:

const preview = await client.previewQuotes(request); // non-binding, nothing to sign
const offer = preview.offers?.[0];                     // { provider, amountOut, … }
if (offer) {
  const quote = await client.prepareQuote(request, offer.provider!); // a signable quote from that provider
  await client.executeQuote({ quote, wallets });
}

An empty offers array is a normal answer: no provider takes this route or amount right now. A prepared quote is bound to a preparationId (a fresh UUID unless you pass one), so repeating the same preparation is safe. When a prepared quote runs low on time, the SDK prepares it again.

The pre-signing checks

The hub routes and prices; it does not decide what the user signs. Before any wallet prompt, executeQuote compares every field that moves money with the request and the catalog, and refuses with a VetError if one row fails. Run the same checks yourself to show them:

const report = await client.vetQuote(quote);
report.ok;     // every row passed
report.rows;   // { check, status: "pass" | "fail" | "skip", detail }[]
report.failed; // the failed rows

Lane	What is checked
every lane	the lane is executable; both chains are in the catalog; the amounts are readable
`wrap-native`	one step, on the source chain, to the catalog’s UserProxy, with `value` = the amount and no approvals; the decoded `wrapAndOpen` order: user, source chain, wrapped-native input and amount, output token, amount, chain and recipient
`swap-token`	the token is the one asked for; one approval, of the UserProxy, capped at the quote’s ceiling; the ceiling within the slippage tolerance; the decoded `swapAndOpenV2` order as above, plus `tokenIn` and `amountInMax`
`evm-permit2`	a Permit2 batch witness on the source chain; the permitted token and amount; the witness’s user, recipient, output token, amount and destination chain; nonce, deadline and expiry present; on an auction, the signed amount is its floor
`solana-escrow`	the message parses, its fee payer is the disclosed solver, and the user signs it; the digest is the message’s hash; the sender is the user and the fee payer is not; with a trusted clock, not expired
`evm-3009`	an EIP-3009 authorization on the source chain, from the user, for the quoted input
`open-flow`	the disclosed steps are on the source chain and target the aggregator the quote names

vetQuote also takes a context: sourceAccounts and destinationAccounts (every account the user may pay from or to, default the request’s), permit2Address, maxSlippageBps, and nowSec, a unix time from a clock you trust (a chain head), which turns on the Solana expiry check.

The catalog

await client.getCatalog() returns a CatalogIndex over one snapshot, cached for 5 minutes (the last good copy is kept when the hub is unreachable):

Method	Answers
`chains`, `assets`	the lists, as the hub declares them
`chain(domain)`, `family(domain)`, `evmChainId(domain)`	one chain; `evm` or `solana`; its EVM chain id
`assetsOn(domain)`, `resolveAsset(domain, keyOrRef)`	a chain’s assets; one asset by key or reference
`canBeSource(domain, key)`, `isNativeSource(domain, key)`, `acceptsTokenIn(domain)`	what the user may pay with
`userProxy(domain)`, `inputSettlers(domain)`, `wrappedKey(domain)`	the contracts the checks compare against

Build pickers from it rather than hard-coding: contract addresses, keys and proxies move when the hub is redeployed.

Get started

Core concepts

Resources

API reference

SDK

SDK reference

A quote request

The quote

How long a quote lives

Reverse quotes

Preview and prepare

The pre-signing checks

The catalog

​A quote request

​The quote

​How long a quote lives

​Reverse quotes

​Preview and prepare

​The pre-signing checks

​The catalog

A quote request

The quote

How long a quote lives

Reverse quotes

Preview and prepare

The pre-signing checks

The catalog