NABLADocs

Build on the API

Swap, bridge and deposit between Solana and five EVM chains through NABLA's API: every direction, call, state and refusal.

Every direction, one API.

For engineers building a product on NABLA's swaps and transfers. NABLA prepares each step, your user signs it in their own wallet, and NABLA never holds funds or keys.

Access. Reads are open to anyone. Requests that start a swap or a transfer are accepted only from NABLA's own site and from sites NABLA has added to its allowlist. There is no sign-up form and no API key: NABLA adds your site by hand.

Request access: message NABLA on Telegram with your site's address (its exact https:// origin) and what you are building.

The fee. NABLA takes 0.5% on every swap and every transfer, whichever exchange or bridge route runs underneath. It is the only fee NABLA takes, and NABLA takes it itself: you add none and configure nothing. What a bridge route itself costs is in its quote (cost).

Who runs on it. Cross ORE (ore.nabladefi.com) is built on these calls and nothing else: deposits in, the ORE miner, swaps and bridges out.

The whole thing in one screen

  1. Base URL: https://www.nabladefi.com/api. JSON in, JSON out. No API key.
  2. Four flows: swap on one EVM chain, bridge between two chains, deposit from an EVM chain into SOL on Solana, swap on Solana. A fifth set of calls runs an ORE miner.
  3. Each flow is four verbs: quote (what the person gets), prepare (what the wallet signs), report (the hash the wallet returned), follow (read the state until it ends).
  4. Swap: POST evm/swap/quote → POST evm/swap/prepare → POST evm/swap/report → GET evm/swap/order.
  5. Bridge: POST bridge/ask + POST bridge/quote → POST bridge/prepare → POST bridge/report → GET bridge/order.
  6. Deposit: POST bridge/deposit/quote → POST bridge/deposit → POST bridge/deposit/report → GET bridge/deposit.
  7. Solana swap: POST quote → POST swaps/prepare → POST transactions/submit → GET transactions/<id>.
  8. Every amount is a string of the asset's smallest unit ("1000000" is 1 USDC), except a Solana swap's, which is a decimal string ("1.5"). Every asset is an id from GET bridge/routes.
  9. NABLA's fee is 0.5% (feeBps: 50) on every swap and every transfer. NABLA takes it itself. You add nothing and configure nothing.
  10. A refusal is { "error": "<sentence for the person>", "code": "<what to do>" } with an HTTP status. Act on code, show error.
  11. prepare answers an intent id (a Solana swap: an id). Keep it with the wallet address: the two together read and drive that swap or transfer.

Before the first call

Reaching the API. The API sends no cross-origin headers, and a preflight request gets a 404. A browser on your site therefore cannot call the base URL directly. Serve /api/* from your own origin and rewrite it to the base URL, as NABLA's own site does. Every POST must carry an Origin header that NABLA has allowed, or it is answered 403 { "error": "Request origin is not allowed", "permanent": true }. A browser sends that header by itself; a server-side caller must set it. GET is not checked. NABLA adds your site's exact HTTPS origin (no path, no wildcard) to the API's PARTNER_ORIGINS setting; ask for it before you test.

Chains. Solana, Ethereum (1), BNB Chain (56), Robinhood Chain (4663), Base (8453), HyperEVM (999).

Asset ids. A chain's coin is eip155:<chain>/slip44:<n>, a token is eip155:<chain>/erc20:<address> (lower case). A Solana asset is its mint. Read them, never build them:

GET bridge/routes (real answer, shortened):

{ "feeBps": 50, "pollS": 5, "paused": false,
  "gum": "https://bridge-api.gum.ag/api/bridge/v2",
  "chains": [
    { "key": "solana", "name": "Solana", "family": "solana", "gum": "solana:mainnet", "send": true },
    { "key": "base", "name": "Base", "family": "evm", "id": 8453, "gum": "evm:8453", "explorer": "https://basescan.org", "send": true } ],
  "assets": [
    { "id": "So11111111111111111111111111111111111111112", "chain": "solana", "symbol": "SOL", "decimals": 9, "native": true, "token": "native" },
    { "id": "eip155:8453/slip44:60", "chain": "base", "symbol": "ETH", "decimals": 18, "native": true, "token": "native" },
    { "id": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", "chain": "base", "symbol": "USDC", "decimals": 6, "native": false, "token": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913" } ] }

pollS is the pace of every wait, in seconds. send: false on a chain means transfers from it are closed. paused: true means no new swap or transfer is taken (one already begun goes on). unavailable: true with empty lists means the bridge could not be read; try again. GET evm/registry gives each EVM chain's public RPC URLs and explorer, for adding the network to a wallet.

The fee. 0.5% of what the person gives.

  • Swap: the fee is inside the swap's own transaction. Nothing extra is signed.
  • Bridge and deposit: the wallet first signs one plain transfer of the fee to NABLA's address. The transfer itself is made only once that fee is proven on chain.
  • Never add a fee of your own through a bridge provider's fee feature. Never pass a fee parameter: there is none.

The wallet. Only a plain wallet (one that sends its own transactions). A smart-contract wallet is refused at prepare with code state. An account that only delegates (EIP-7702) is accepted.

Signing a step. Every EVM step is { "chainId", "to", "data", "value", "gas" } under request.evm. Switch the wallet to chainId, then send exactly to, data, value (decimal string; convert to hex), and gas when it is not null. Do not rebuild or re-encode anything.

1. Swap on one EVM chain

A swap is named by token and settle, both asset ids on the same chain. side: "buy" pays settle and receives token; side: "sell" is the reverse. If the chain's coin is in the pair it must be the settle side. For a launch NABLA lists, settle may be left out.

Before any amount: GET evm/swap/route?token=<id>&settle=<id> (real answer):

{ "token": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", "chainId": 8453, "tradable": true, "dex": "Uniswap",
  "settle": { "id": "eip155:8453/slip44:60", "symbol": "ETH", "decimals": 18, "native": true },
  "hops": 1, "reserve": "100000000000000", "feeBps": 50, "slippageBps": 100, "maxSlippageBps": 2000,
  "maxImpactBps": 1000, "pollS": 5, "open": true, "paused": false }

tradable: false comes with a reason to show. reserve is what a buy paid in the chain's coin must leave in the wallet for network fees (null when settle is a token).

Quote: POST evm/swap/quote

FieldTypeMeaning
token, settlestringAsset ids, as above
side"buy" | "sell"
amountstringWhat the person gives: settle units for a buy, token units for a sell
slippageBpsinteger, "any", or absentAbsent: NABLA's usual (slippageBps of the route). "any": NABLA climbs until the swap goes through

Example request and answer (example values):

{ "token": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", "settle": "eip155:8453/slip44:60", "side": "buy", "amount": "2000000000000000" }
{ "token": "eip155:8453/erc20:0x8335…2913", "side": "buy", "chainId": 8453,
  "settle": { "id": "eip155:8453/slip44:60", "symbol": "ETH", "decimals": 18, "native": true }, "hops": 1,
  "amountIn": "2000000000000000", "fee": { "amount": "10000000000000", "bps": 50, "asset": "eip155:8453/slip44:60" },
  "amountOut": "6412345", "minAmountOut": "6348221", "slippageBps": 100, "slippageMode": "auto", "impactBps": 3,
  "taxBps": 0, "pairTaxBps": 0, "inUsd": 6.45, "outUsd": 6.41, "settleUsd": 3225.1,
  "expiresAt": 1794922045000, "ttlMs": 20000 }

A buy's fee comes off amountIn first; a sell's comes off what the swap gives, so amountOut is already after the fee. Count the quote's life from ttlMs when it arrives, not from your clock.

Prepare: POST evm/swap/prepare, the quote's body plus wallet. It quotes again by itself; you do not send the quote back. Answer (example, shortened):

{ "intent": "5b0c1f0e-…", "state": "signing", "side": "buy", "chainId": 8453, "wallet": "0xabc…",
  "amountIn": "2000000000000000", "amountOut": "6412345", "minAmountOut": "6348221", "deadline": 1794922625,
  "fee": { "state": "quoted", "amount": "10000000000000", "bps": 50, "asset": "eip155:8453/slip44:60", "tx": null },
  "steps": [
    { "n": 1, "kind": "approve", "request": { "evm": { "chainId": 8453, "to": "0x8335…", "data": "0x095ea7b3…", "value": "0", "gas": "61234" } } },
    { "n": 2, "kind": "swap",    "request": { "evm": { "chainId": 8453, "to": "0x…",    "data": "0x3593564c…", "value": "0", "gas": null } } } ],
  "gasPrice": "5200000", "tx": null, "result": null, "error": null }

The last step is always the swap. Steps before it are approvals (approve, permit), listed only when not already in place. Do as NABLA's own page does:

  1. If there is more than one step: sign each approval in order and wait for each to be mined.
  2. Then either sign the swap step as it was handed (its gas is null: leave gas out and the wallet estimates it), or call prepare again for a fresh quote and a swap step with its own gas (a new intent; NABLA's page does this). Use the first when one intent per swap matters more than a fresh quote.

The swap must be mined before deadline (Unix seconds).

Report: POST evm/swap/report with { "intent", "wallet", "txHash" }: the swap step's hash only. Approvals are not reported.

Follow: GET evm/swap/order?intent=<id>&wallet=<address> every pollS seconds until state is settled, failed or unknown. A settled swap's result is { "status": "settled", "hash", "block", "fee", "received", "gasFee" }.

GET evm/swaps?wallet=<address> lists a wallet's sent swaps.

2. Bridge between two chains

NABLA picks the route: the fastest first; a slower one only when the fastest costs over 1% and the slower one is at least 5 points cheaper; nothing that costs more than 5% of the amount. The rules in force come back in every quote as rules.

Quote: two calls and one in between. The bridge provider's routes take a browser's call, so the page fetches them and NABLA checks them.

  1. POST bridge/ask with the ask below. Answer: { "url", "body" }.
  2. POST that body as JSON to that url, from the browser. Keep the JSON answer whole.
  3. POST bridge/quote with the same ask plus "answer": <that JSON>.
FieldTypeMeaning
from, tostringAsset ids on two different chains
amountstringWhat the person gives, fee included
senderstringThe wallet that sends, on from's chain
recipientstringThe address that receives, on to's chain

Answer of bridge/quote (example, shortened):

{ "from": "eip155:8453/erc20:0x8335…2913", "to": "So11111111111111111111111111111111111111112",
  "spend": "10000000", "fee": { "amount": "50000", "bps": 50, "asset": "eip155:8453/erc20:0x8335…2913" }, "input": "9950000",
  "choice": { "quoteId": "…", "router": "relay", "name": "Relay", "amountOut": "61250000", "minAmountOut": "60760000",
              "cost": 0.4, "seconds": 9, "estimate": false, "expiresAt": 1794922080000, "slower": false, "reason": "fastest" },
  "routes": [ … ], "none": null, "rules": { "ceiling": 5, "band": 1, "save": 5 }, "refused": [], "belowMinimum": null }
  • choice is the route to offer. Keep its router and minAmountOut. Its amountOut, minAmountOut and expiresAt are also at the top of the answer, with ttlMs (how long the quote holds), under the same names a swap quote uses.
  • Into an asset whose price moves more between a quote and its order (HyperEVM's USDC today), minAmountOut leaves more room under the route's own figure. It is the figure the person accepts and the order must meet.
  • choice: null with none: "above-ceiling": every route costs too much. With none: "no-route": nothing is offered; if belowMinimum is set, the amount is too small, and it says the least (minimumAmount, minimumUsd). These are 200 answers, not refusals.
  • A quote is good until choice.expiresAt (milliseconds).

Prepare: POST bridge/prepare with the ask plus "router" and "minAmountOut" from choice. Answer (example, shortened):

{ "intent": "9d2e…", "state": "fee", "wallet": "0xabc…", "recipient": "7xKX…", "spend": "10000000", "input": "9950000",
  "router": "relay", "minAmountOut": "60760000",
  "fee": { "state": "quoted", "amount": "50000", "bps": 50, "asset": "eip155:8453/erc20:0x8335…2913", "tx": null,
           "request": { "evm": { "chainId": 8453, "to": "0x8335…", "data": "0xa9059cbb…", "value": "0" } } },
  "order": null, "late": false, "sourceTx": null, "result": null, "error": null }

Then, in order:

  1. Fee. Sign fee.request.evm. POST bridge/report with { "intent", "wallet", "txHash" }.
  2. Order. POST bridge/prepare with { "intent", "wallet" } every pollS seconds. While the fee is being proven it answers state: "fee"; the call that finds it proven makes the order in the same answer (or answers fee-failed). No other call is needed in between. The state becomes ordered and order holds the steps: { "id", "expiresAt", "seconds", "steps": [ { "n", "kind", "done", "tx", "request": { "evm": { … } } } ] }. kind is approve or send; the last step is the send.
  3. Steps. Sign each step in order. After each, POST bridge/report with { "intent", "wallet", "order": <order.id>, "step": <n>, "txHash" }. After an approval, read bridge/order until that step is done before signing the next. A step with no request is not to be signed (its order ran out): keep reading.
  4. Follow GET bridge/order?intent=&wallet= until a final state. A delivered transfer's result is { "status": "delivered", "sourceTx", "destinationTx", "received", "landedAt", "ms" }. late: true means it is taking longer than usual, nothing more.

If the state returns to ready after step 2, nothing left the wallet (the order ran out, or the sending transaction failed). Call bridge/prepare with { "intent", "wallet" } again: the paid fee carries, for a few orders. Never start a new transfer for it; that would be a second fee.

When a bridge sends from Solana, fee.request and a step's request hold solana: { "id", "transaction", "expiresAt" } instead: a base64 transaction to sign with the Solana wallet and hand back through POST transactions/submit ({ "id", "signedTransaction": <base64>, "wallet": <the wallet app's name> }), before expiresAt. NABLA sends it; it is not reported.

GET bridge/history?wallet=<address> lists a wallet's transfers.

3. Deposit by address (EVM → SOL on Solana)

The simplest route in: the wallet signs two plain transfers and never an approval: the fee, then the deposit. It delivers SOL.

Quote: POST bridge/deposit/quote

FieldTypeMeaning
fromstringAsset id of the coin or token sent
amountstringWhat the person gives, fee included
senderstringThe EVM wallet
recipientstringThe Solana address that receives
destinationstring"solana" (the only one; also the default)

Answer (example): receive and minimum are lamports. The same two figures are also given as amountOut and minAmountOut, the names a swap and a bridge use.

{ "from": "eip155:8453/slip44:60", "spend": "2000000000000000",
  "fee": { "amount": "10000000000000", "bps": 50, "asset": "eip155:8453/slip44:60" },
  "input": "1990000000000000", "receive": "38410000", "minimum": "38200000",
  "amountOut": "38410000", "minAmountOut": "38200000" }

Prepare: POST bridge/deposit with the quote's body plus "minimum" (or "minAmountOut") from the quote. Answer (example, shortened):

{ "intent": "c41a…", "kind": "deposit", "state": "paying", "from": "eip155:8453/slip44:60", "destination": "solana",
  "wallet": "0xabc…", "recipient": "7xKX…", "spend": "2000000000000000", "input": "1990000000000000", "minimum": "38200000",
  "fee": { "state": "quoted", "amount": "10000000000000", "bps": 50, "asset": "eip155:8453/slip44:60", "tx": null,
           "request": { "evm": { "chainId": 8453, "to": "0xedd0…", "value": "10000000000000", "data": "0x" } } },
  "tx": null, "result": null, "error": null, "createdAt": 1794922000000 }

Then:

  1. Fee. Sign fee.request.evm. POST bridge/deposit/report with { "intent", "wallet", "txHash" }.
  2. Wait on GET bridge/deposit?intent=&wallet= until state is address. The answer then holds deposit, in one of two shapes:
    • { "address", "amount", "asset", "strict", "request": { "evm": {…} } }: send request.evm as it is (the same { chainId, to, value, data } shape as the fee): it is exactly amount of asset to address, a plain send for a coin and the token's own transfer(address, amount) for a token, already encoded. strict: true is a single-use address: send once.
    • { "request": { "evm": { "chainId", "to", "value", "data" } } }: send that call as it is (HyperEVM's HYPE).
  3. Deposit. Sign it. POST bridge/deposit/report with { "intent", "wallet", "txHash" }.
  4. Follow bridge/deposit until delivered, refunded or failed. result holds sourceTx, destinationTx and received (lamports).

While the state is ready, read error:

  • The price moved under the accepted minimum: result.offered is the new minimum. Show it; on the person's yes, POST bridge/deposit with { "intent", "wallet", "minimum": <offered> }. The paid fee carries.
  • No address just now, or an address ran out: keep reading; each read asks again.

GET bridge/deposits?wallet=<address> lists a wallet's deposits that have not ended (no ids: keep your own intent).

4. Swap on Solana

A swap between a token NABLA lists and SOL, USDC or USDT, through Jupiter. The person's Solana wallet signs one transaction; NABLA sends it.

Quote: POST quote

FieldTypeMeaning
mintstringThe token's mint. It must be a token NABLA lists (GET catalog)
side"buy" | "sell"Buy pays the settlement asset and receives the token; sell is the reverse
amountstringWhat the person gives, as a decimal ("1.5"): the settlement asset for a buy, the token for a sell
settlement"SOL", "USDC" or "USDT"Absent: USDC
slippageBpsinteger, "auto", "any", or absentAbsent: set per order by the route
walletstringThe Solana wallet. Needed at prepare; at quote only with "auto"

Prepare: POST swaps/prepare, the same body with wallet. Answer: a prepared transaction.

{ "id": "<uuid>", "kind": "swap", "wallet": "<Solana address>", "state": "prepared", "chain": "solana",
  "createdAt": 0, "expiresAt": 0, "signature": null, "result": null, "error": null,
  "transaction": "<base64 unsigned transaction>", "messageHash": "<hash>", "review": { … } }

review says what the transaction does and the most it can take from the wallet. Sign transaction as it is, before expiresAt. Do not rebuild it: a transaction that differs from the one prepared is refused.

Submit: POST transactions/submit with { "id", "signedTransaction": <base64>, "wallet": <the wallet app's name> }. NABLA sends it; nothing is reported.

Follow: GET transactions/<id> until state is finalized, failed or expired. error holds the sentence to show. A transaction that expired unsigned moved nothing: prepare again.

The fee is inside the swap's own transaction, as on an EVM chain.

5. Run an ORE miner

For a product that mines ORE for its user, as Cross ORE does. The wallet is the person's own Solana address (the "ORE address"); NABLA prepares each action and never holds its key.

Read: GET ore/miner?wallet=<ORE address>. Answers the round now (round: id, endsAtSlot, 25 tiles, motherlode), the wallet's SOL (sol), its automation (null when none: amount, mask, reload, strategy, conditions, roundsLeft, …) and its miner (rewards and holdings). Numbers are strings. Without wallet it answers the round alone.

Act: POST ore/prepare

{ "wallet": "<ORE address>", "action": "automate",
  "settings": { "amount": "10000", "deposit": "1000000", "mask": "3", "reload": "0", "strategy": "0",
                "conditions": { "minMotherlode": "0", "maxMotherlode": "65535", "soloTiles": "0", "splitTiles": "0" } } }

action is automate (start or change the miner; the only one that takes settings), stop or claim. The answer is a prepared transaction in the same shape as a Solana swap's, with "kind": "program_action": sign it and hand it to POST transactions/submit, then follow GET transactions/<id>.

A refusal is 400 { "error", "code" }, the code naming what was refused: executor, fee, strategy, mask, amount, reload, tiles, motherlode, no-automation, round-open (with endsAtSlot: wait for the round to end), simulation, debit, wallet, action.

The whole trip Cross ORE makes is these calls in order: a deposit by address into the ORE address (flow 3), ore/prepare to mine, ore/prepare to claim, a Solana swap of the ORE for SOL (flow 4), and a bridge out (flow 2).

States

Final means: stop reading.

FlowStateMeaningFinal
Solana swap, ORE actionpreparedThe transaction is with the wallet
Solana swap, ORE actionfinalizedLanded and finalyes
Solana swap, ORE actionfailed, expiredDid not land; nothing movedyes
SwapsigningSteps are with the wallet
SwapsentHash reported, not settled yet
SwapsettledMined and proven; result.receivedyes
SwapfailedReverted, or not the swap prepared; nothing tradedyes
SwapunknownIn no block inside the watch time; a later read can still settle itstop, read again later
BridgefeeFee not proven yet
BridgereadyFee proven, no order: call prepare with the intent
BridgeorderingAn order is being made
BridgeorderedSteps to sign
BridgefundedFunds sent, in flight
BridgedeliveredArrived; result.receivedyes
BridgerefundedSent back to the sender (the fee is kept)yes
Bridgefailed, expiredThe bridge's own endyes
Bridgefee-failedThe fee transaction failed; nothing ranyes
BridgeunknownNo end inside the watch timestop, read again later
DepositpayingFee not proven yet
DepositreadyFee proven, no address yet (read error)
Depositaddressdeposit says where to send
DepositdepositedDeposit seen, in flight
DepositdeliveredSOL arrivedyes
DepositrefundedSent back to the sender (the fee is kept)yes
DepositfailedCould not be filled or refundedyes
Depositfee-failedThe fee transaction failed; nothing ranyes
DepositunknownNo end inside the watch timestop, read again later

fee.state inside every answer is the fee's own: quoted → sent → proven, or failed.

Refusals

{ "error", "code" }, sometimes with retryAfterMs (also a retry-after header) or forget.

codeStatusFlowsMeaningWhat to do
input400allThe request is wrong (asset, amount, address, hash, too small for a fee)Fix it; show error
unknown404allNo such intent for this walletDrop the intent
untradable409swapThis pair or launch cannot be tradedShow error
state409allNot now: smart-contract wallet, wallet holds too little, would fail now, already sent, step out of turnShow error; do not retry as is
fee409bridgeThe fee is not proven yetKeep reading, then prepare again
requote409bridgeThe route changed after the fee was paidQuote again, then bridge/prepare with { intent, wallet, router, minAmountOut } for the same intent
route409bridge, depositThe route's transaction was not what was asked; nothing was sentBridge: quote again and accept another route for the same intent. Deposit: read again later
refused400bridge, depositThe provider said noShow error
busy429bridge, depositWait; also when the wallet's other transfer of the same asset is still going outAsk again after retryAfterMs
rate_limited429allToo many calls from this callerAsk again after retryAfterMs
unavailable503allA chain or provider gave no answer, or new trades are pausedAsk again at pollS
unset503bridge, depositThis side is closed by NABLADo not retry; show error
none403allOrigin not allowed (permanent: true)Get your origin added
none400allBody is not a JSON object, or too largeFix the request
none500allNABLA's own failureAsk again at pollS

forget: true on a report refusal means NABLA has no use for that hash: let it go. Without it, keep the hash and report it again.

A call that got no answer, a 429 and a 5xx (except unset) may be made again. One exception: the first prepare of a new bridge or deposit. Asked twice it is two transfers.

What goes wrong

  • Smart-contract wallets. Refused at prepare (state). Say so before the person types an amount if you can tell.
  • Not enough in the wallet. prepare refuses (state) before any fee is asked. A deposit of the chain's coin needs the amount plus the chain's reserve; a swap of a token needs the amount; a bridge of the chain's coin needs the amount plus the chain's reserve too, so take the reserve off when you offer "Max". Reserves today: Ethereum 0.001 ETH, BNB Chain 0.0005 BNB, Robinhood Chain 0.0001 ETH, Base 0.0001 ETH, HyperEVM 0.01 HYPE. Read the live figure from each chain's reserve in GET bridge/routes (or from reserve of GET evm/swap/route with the chain's coin as settle).
  • Quotes expire. Swap: ttlMs. Bridge: choice.expiresAt, then order.expiresAt for signing. Quote again; do not sign late.
  • Amount too small. input when the fee would round to nothing; belowMinimum in a bridge quote.
  • A paid fee is never paid twice. Keep the intent. A new order, a new minimum or a new address all go to the same intent.
  • Approvals come first and in order. Wait for each to be mined. A bridge's approval is reported; a swap's is not.
  • HyperEVM buys. The swap step's to is Multicall3, not a router. Send the step as given.
  • Keep the hash before you report it. Store the wallet's hash the moment it returns. If the report fails, report the same hash again; never sign again.
  • Sped-up transactions. Report the new hash; it replaces the old one while the old one is in no block.
  • One transfer at a time. A second bridge of the same asset from the same wallet waits (busy) until the first has gone out.
  • Closed page. On return, read the intent (GET …/order or GET bridge/deposit) and go on from its state. Unsigned steps are still in the answer.
  • Paused. paused: true in bridge/routes or evm/swap/route: quotes may still answer, prepare refuses with unavailable.

On this page