Errors

Every refusal is JSON with a stable code and a readable message:

JSON

{"error": {"code": "NOT_AS_BUILT", "message": "this transaction isn't one Orblivion built for this API key: its calldata differs from the latest swap built 0 s ago", "diffs": ["calldata"]}}

Branch on code, never on message. Some errors carry more fields beside them: unaccepted, blocked and policy (risk refusals), policy (the checks that ran), diffs (NOT_AS_BUILT), checks (session checks), signer_checks (the co-signer's failed checks), sent (what a two-step submit already sent), retry_after_s. A 429 and most 503s carry a Retry-After header.

Retrying. 429, 502 and 503 are worth retrying after a pause (Retry-After when there is one; after SIGNUP_CAPPED or KEYS_CAPPED it can be hours), and so are TOKEN_CHANGED, QUOTE_SIM_MISMATCH, ROUTE_VS_MID and ROUTE_VS_REF with a fresh plan. A 400 or 422 needs a different request. After SEQUENCER_UNREACHABLE, look for the transaction's receipt before you sign another with the same nonce.

Requests and authentication#

Code	Status	Meaning
`BAD_REQUEST`	400	a field is missing or malformed, the body isn't a JSON object, or it is over 64 KB (413)
`UNKNOWN_FIELD`	400	a hosted-agent request named a field that route doesn't take
`ADDRESS_REQUIRED`	400	a token named by a symbol that isn't a core asset: use its address
`LENGTH_REQUIRED`	411	a body sent without a plain `Content-Length` (chunked bodies aren't accepted)
`METHOD_NOT_ALLOWED`	405	the wrong HTTP method for the route
`NOT_FOUND`	404	no such route, or no such object for this key
`UNAUTHORIZED`	401	no API key, or an unknown, expired or revoked one
`CHALLENGE_EXPIRED`	401	no open sign-in challenge for the address: it expired (5 minutes) or was used
`BAD_SIGNATURE`	400, 401, 422	a signature that doesn't recover to the wallet: sign-in, a session's delegation or authorization
`NOT_ORBIO_AGENT`	403	this server signs in only Orbio agents' wallets and owners
`WALLET_MISMATCH`	403	the key is bound to another wallet than the request, the transaction or the session names
`WALLET_NOT_BOUND`	403	a key bound to no wallet, on a route that needs one (trading, sessions, hosted agents, your account): sign in with the wallet
`FORBIDDEN`	403	another wallet's hosted agent
`CSRF_REFUSED`	403	a browser request from another origin, or with cookies but without JSON and `X-Pit-Client`
`DEV_DISABLED`	403	a development-only field (`fee_recipient`, `assume_state`) on a server where they are off
`RATE_LIMITED`	429	too many requests (from this address, or from everyone at once on the public API), failed authentications or new-token screens: wait for `Retry-After`
`SIGNUP_CAPPED`	429	wallet sign-in would create a new account past the cap for this address today or for the whole service this hour: wait for `Retry-After` (it can be hours), or sign in with a wallet that already has an account
`KEYS_CAPPED`	429	wallet sign-in would issue a new API key past the cap for this address today or for the whole service this hour: keep using the keys you have, or wait for `Retry-After`
`UNKNOWN_HOST`	421	the request named a host this server doesn't answer for: check the base URL
`SANCTIONED`	451	an address the request involves is on the US Treasury's sanctions list (OFAC's SDN list): the wallet signing in, the wallet an API key is bound to, the trading wallet, a transaction's signer, a session's wallet or executor, a hosted agent's owner, or a league entry's owner, agent wallet or beneficiary. `field` names which. Orblivion serves it nothing; a key bound to it can still revoke itself and end what it started (revoke a session, pause, stop or delete a hosted agent, leave the league)
`COUNTRY_BLOCKED`	451	the request comes from a country or region under comprehensive US sanctions (Cuba, Iran, North Korea, Syria, and Ukraine's Crimea, Donetsk and Luhansk regions), which the Terms exclude
`ENGINE_UNAVAILABLE`	503	the service is starting or down: retry shortly
`AUTH_DOMAIN_UNSET`	503	the server has no sign-in domain configured, so wallet sign-in is off
`ORBIO_UNAVAILABLE`	503	Orbio's agent list couldn't be read, on a server that signs in only agents

Tokens#

Code	Status	Meaning
`NO_ROUTE`	422	no venue Orblivion can build a trade through: the only refusal about a token itself
`TOKEN_NOT_ALLOWED`	422	a symbol that isn't a core asset (name other tokens by address), or a token outside a session's list
`TOKEN_UNKNOWN`, `UNKNOWN_TOKEN`	422, 404	the address isn't in the registry, or isn't a token
`NOT_A_TOKEN`	404	the address isn't an ERC-20 contract on Robinhood Chain
`SAME_TOKEN`	422	the input and the output are the same token
`TOKEN_CHANGED`	409	the token's proxy now runs other code than its screen read; it is being screened again: retry shortly
`SCREEN_UNAVAILABLE`	503	the token couldn't be screened right now (every screening slot is busy): retry after `Retry-After`
`REGISTRY_UNAVAILABLE`	503	the token registry didn't answer
`STATS_PENDING`	503	the registry's first count is still running
`DOSSIER_UNAVAILABLE`	503	a Shield request whose Dossier verdict couldn't be read: never treated as verified. Retry after 15 seconds, or trade without Shield.

Risk and policy#

Code	Status	Meaning
`RISK_NOT_ACCEPTED`	422	severe risks the request (or the session's binding) doesn't accept; listed in `unaccepted`
`RISK_BLOCKED`	422	a Dossier Shield policy refuses the trade; the codes in `blocked`, the policy in `policy`
`MAX_NOTIONAL`	422	above the most one trade may be ($10,000)
`MIN_NOTIONAL`	422	below the least one trade may be ($1)
`MAX_SLIPPAGE`	422	`slippage_bps` over the pair's cap for the size
`MAX_FEE`	422	a fee above the server's maximum
`FEE_FIXED`	422	the request named a fee (`fee_bps`): the server sets it from the trade's class, the wallet's volume tier and Shield, or a session's binding. Cap it with `max_fee_bps` instead.
`FEE_BPS`	422	the plan's fee isn't one the schedule allows for its class and Shield, or is above the request's `max_fee_bps`
`FEE_RECIPIENT_NOT_ALLOWED`	422	a request for another fee recipient
`FEE_MISMATCH`	422	the fee in the calldata isn't the one the plan's class, tier and Shield (or a session's binding) set
`ROUTE_VS_MID`	422	the route lands too far under the pair's reference pool mid
`ROUTE_VS_REF`	422	the route's price sits too far from the token's independent reference
`NO_REFERENCE_MID`	422	the pair's reference mid couldn't be read, so the route can't be checked
`LIMIT_NOT_REACHABLE`	422	`min_amount_out` can't be met at this size now
`QUOTE_ONLY`	422	the route can be quoted but not built for signing (an aggregator)
`QUOTE_SIM_MISMATCH`	422	the plan's exact simulation delivers less than its quote (a hook or token that treats the router differently)
`SIMULATION_FAILED`	422	the plan's own simulation reverted or didn't deliver what was asked
`DRY_RUN_UNFUNDABLE`	422	a dry run of a sale couldn't pretend the wallet holds the token (its balance storage isn't a standard mapping): simulate from a wallet that holds it (`fund: false`), or trade a small real amount
`ROUTER_NOT_ALLOWED`	422	a transaction to a contract, or a call, that Orblivion doesn't build
`PARTICIPANT_TOKEN`	422	a token that a trading league's rules exclude for this account
`TOKEN_TIER`		a policy check that reports a token's tier; informational
`APPROVAL_MODE`	422	`approval_mode` isn't `budget`, `exact` or `unlimited`
`APPROVAL_BUDGET`	422	the approval budget isn't a positive amount within the maximum
`UNLIMITED_APPROVAL`	422	an unlimited approval without `allow_unlimited_approval: true`
`UNLIMITED_APPROVAL_IN_PLACE`		a warning check: the wallet already has an unlimited approval; revoke it
`GEOFENCE`	422	a stock token without `owner_attests_non_us: true`: stock tokens aren't for US persons
`STOCK_PAUSED`	422	the stock token is paused
`WALLET_BLOCKED`	422	the stock token's registry blocks this wallet
`NO_MARK`	503	no price for a token, so a dollar size can't be converted

Curve trades#

Code	Status	Meaning
`CURVE_PAIR`	422	a Pons curve trades only against its own pair token
`CURVE_GRADUATED`	422	the curve has graduated, or this buy would take it to graduation and be only partly filled: buy less, or trade the pool
`SNIPE_TAX`	422	the curve charges a snipe tax in a launch's first seconds: try again a few seconds later
`FEE_MODE`	422	the curve fee mode doesn't fit the wallet (`batch` needs a delegated wallet)
`FEE_TOO_SMALL`	422	the fee would round to zero: trade more
`FEE_FIRST`	422	a curve trade's fee must go first, with its trade: send them together in `raw_txs`

Relay#

Code	Status	Meaning
`SUBMIT_DISABLED`	403	this server doesn't relay: send the signed transaction through any RPC
`NOT_AS_BUILT`	422	the transaction isn't one Orblivion built for this key, or the fee differs; the fields in `diffs`
`SUBMIT_REJECTED`	422	the sequencer, or the relay's own decoding, refused the transaction
`SEQUENCER_UNREACHABLE`	502	the sequencer didn't answer: the transaction may or may not have arrived
`RPC_UNAVAILABLE`	502	the chain's RPC didn't answer, or couldn't tell whether a token by address is a Robinhood stock token, so the trade's fee class can't be read; retry shortly
`VENUE_FAILED`	502	a venue's quote or curve read failed
`LIVE_UNAVAILABLE`	503	the trading layer isn't running on this server

Fast mode#

POST /api/v1/live/fast checks a signed transaction against the rules below, in this order, and answers the first that fails; failures lists every one that failed. Each is also a rule the SDKs' own verify_fast / verifyFast report. Every code down to SIMULATION_FAILED and FAST_FUNDS is answered before anything is relayed. NONCE, SUBMIT_REJECTED, SEQUENCER_UNREACHABLE and IN_FLIGHT come after the relay may have reached the sequencer: never sign another transaction for the same trade until the chain shows the hash, or shows the nonce taken by something else (the SDKs do this themselves).

Code	Status	Meaning
`FAST_DISABLED`	403	fast mode is off on this server (it is opt-in); use `prepare` and `submit`
`BAD_REQUEST`	400	the body or `raw_tx` can't be read (`field` names it): not hex, not RLP, not a transaction
`TX_ENCODING`	422	`raw_tx` isn't in the one encoding fast mode takes: canonical RLP, a low-s signature, an empty access list
`FAST_PAIR`	422	the pair and direction have no pinned fast route (cbBTC, ORBIO, launchpad, Pons and long-tail tokens never do)
`MARKET_CLOSED`	422	a stock token outside the US stock-token session (Sunday 20:00 to Friday 20:00, New York)
`PRICE_STALE`	503	Orblivion's own Chainlink mark for an end is missing or stale; retry shortly
`TX_TYPE`	422	not an EIP-1559 (type 2) transaction
`CHAIN_ID`	422	not signed for chain 4663
`ROUTER`	422	not to the pinned Universal Router
`VALUE`	422	the ETH sent isn't the ETH input (or 0 for a token input)
`WALLET_MISMATCH`	403	signed by another key than this API key's wallet
`NOTIONAL`	422	under $1 or over the server's maximum notional
`ROUTE_CAP`	422	over the pinned route's own size cap (`max_usd` in the routes table, at Orblivion's marks): above it the pinned pool trails the normal path's best route, so the trade goes through `prepare` (the SDKs take the normal path themselves, before signing)
`DEADLINE`	422	the deadline has passed or is more than 60 s away
`GAS`	422	the gas limit is under the pinned route's or over 1,000,000; `maxFeePerGas` under the base fee or over 10 times it; the tip over the fee cap; or the most the transaction can cost over 0.0002 ETH. `terms.base_fee_wei` is the server's
`FEE_BPS`	422	the declared `fee_bps` or the calldata's fee (an input-side `TRANSFER` of exactly the bps of the input, an output-side `PAY_PORTION`) isn't this wallet's fee; `terms.fee` is the right one
`MIN_OUT`	422	`min_out` is more than the pair's cap under what the trade delivers now (by the simulation), or further under Orblivion's own Chainlink marks than the cap, the pool's fee and the pair's band (75 bps against USDG, 125 for a cross pair) together; `terms.floor` is the least it takes: quote again
`AMOUNT_USD`	422	`amount_in` is worth more than 3% away from the `amount_usd` the trade was sized for, at Orblivion's own Chainlink marks: the sizing marks are wrong
`CLIENT_CAP`	422	`amount_in` is worth more than the request's own `max_notional_usd` at Orblivion's marks
`PERMIT`	422	the Permit2 permit isn't for exactly this trade, expires too late, or rides on an ETH input
`NOT_AS_BUILT`	422	the calldata isn't byte for byte what Orblivion builds from the request; `diffs` names what differs (`CALLDATA`, `FEE_RECIPIENT`, `FEE_COUNT`, `FEE_TOKEN`, `FEE_SIDE`, `RECIPIENT`, `ROUTE`, `COMMANDS`, `AS_BUILT`)
`GEOFENCE`, `STOCK_PAUSED`, `WALLET_BLOCKED`	422	a stock token: as for `prepare`
`SIMULATION_FAILED`	422	the exact signed transaction failed its simulation (it would revert, deliver under `min_out`, or pay the fee wrongly); `simulation.checks` says which
`POOL_FAR`	422	the pinned pool delivers further under Orblivion's Chainlink marks than its fee and the pair's band: a pool pushed off the market isn't traded fast
`ROUTE_VS_MID`, `NO_REFERENCE_MID`	422	on an NVDA or SPY pair, the delivery (or, without the simulation, the minimum) lands too far under the reference pools' mid, or the mid can't be read
`FAST_FUNDS`	422	with `simulate: false`, the wallet doesn't hold what the transaction spends
`NONCE`	422	the sequencer refused the nonce and the chain doesn't show these bytes; `chain.spent` true means another transaction took the nonce, so this one can never land. Otherwise it may still land: look the hash up before signing anything else
`SUBMIT_REJECTED`, `SEQUENCER_UNREACHABLE`	422, 502	the sequencer refused it, or its answer was lost; it may have arrived
`IN_FLIGHT`	409	the same signed bytes are still being relayed by another call: wait for it, and look the hash up

Sessions#

Code	Status	Meaning
`NO_SESSION`	404, 409	no such session for this key, or (hosted agents) none attached
`SESSION_LIMIT`	422	a grant's limits are out of range
`BAD_EXECUTOR`	422	the executor is the wallet or the co-signer
`EXECUTOR_OWNER`	403	the executor is a hosted agent's: only that agent's owner can grant it a session
`WALLET_CODE`	422	the wallet runs other code than EIP7702StatelessDeleGator v1.3.0; changing it is the owner's decision
`SESSION_PENDING`, `SESSION_REVOKED`, `SESSION_EXPIRED`	409	the session isn't switched on, was revoked, or has ended
`SESSION_EXPIRY`	409	the session ends in the next few seconds
`SESSION_BOUND`	409	the stored binding doesn't hash to the root's salt; grant again
`SESSION_TERMS`	400	a trade asked for other risk terms than the session's binding
`SESSION_TOKENS`	422	a token outside the session
`SESSION_TRADES_LEFT`	422	the session's trades are used up
`SESSION_MAX_TRADE`	422	over the per-trade cap
`SESSION_MAX_DAY`	422	over the 24-hour cap (every co-signed trade counts, sent or not)
`SESSION_TARGET`, `SESSION_RECIPIENTS`, `SESSION_EXECUTION`	422	the swap isn't a router call the root allows, or pays someone other than the wallet, the router or the fee recipient
`SESSION_SETUP`	422	a token input without the session's Permit2 setup in place
`SESSION_CURVE`, `SESSION_CURVE_ROOTS`, `SESSION_CURVE_STEPS`, `SESSION_ROOT_ALLOWS`	422	a curve token's trade the session's curve roots don't allow
`TOKEN_UNVERIFIED`	422	a session granted before binding version 3 trading a token Dossier hasn't verified and the session didn't list
`SESSIONS_UNAVAILABLE`, `SIGNER_REQUIRED`, `SIGNER_UNAVAILABLE`	503	sessions can't be co-signed on this server right now
`SIGNER_MISMATCH`	502	the co-signer's answer wasn't the leaf asked for; nothing was co-signed

The co-signer's refusals#

When the co-signer refuses a session trade, the error's code is its own (REFUSED when the trade fails its checks) and signer_checks lists the checks that failed, each by its rule. The usual codes and rules:

Code or rule	Meaning
`REFUSED`	the session trade failed the co-signer's checks; `signer_checks` names them
`SIGNER_FROZEN`	the co-signer is frozen by its operator: it signs nothing
`PRICE`, `PRICE_UNAVAILABLE`	the minimum output is too far under the input at the co-signer's own price, or it has no fresh price
`SIGNED_MARK_PRICE`	a token without a feed, priced too far under the mark the owner signed
`FEE_REQUIRED`	the leaf doesn't pay a fee its binding allows for the leaf's class to the fee recipient: a major leaf one of the pinned tiers between `major_min_bps` and `major_max_bps`, any other leaf exactly `other_bps`
`FEE_CLASS`	the co-signer couldn't read the leaf's fee class itself (whether a token by address is on the Robinhood stock tokens' beacon); it reads the class from the leaf's two tokens and never takes Orblivion's
`SESSION_FEE`, `FEE_DECLARED`	no fee is allowed for the leaf (its class couldn't be read), or the fee Orblivion states for it isn't one the session's binding allows for its class
`SLIPPAGE`	the slippage asked is over the co-signer's maximum
`ROOT_BINDS_LIMITS`, `BINDING_NONCE`, `BINDING_TERMS`	the root's salt isn't the hash of the limits, or the binding is malformed
`ROOT_DAY_CAP`	a hosted executor's root without the on-chain ETH day cap
`CAP_PRICE`	a registered cap far from the co-signer's own price
`NO_FEED_SESSION`	a session with a token without a feed that lasts over 24 hours
`ROOT_REUSED`	the same signed root registered twice
`TRADE_REFUSED`, `TX_REFUSED`	the trade, or an executor's transaction, failed the co-signer's checks
`REFUND_REFUSED`	an executor's gas can't go back yet: a session for it can still be co-signed, something it signed can still execute, or nothing is left above the refund's own gas (`checks` says which)
`REFUND_OWNER`	the executor's owner on record isn't one the co-signer can stand on (none, or not the wallet that signed its sessions): nothing is refunded
`REFUND_IN_FLIGHT`	an earlier refund is ahead of what the chain shows: try again shortly
`SANCTIONED`	the session's wallet or executor, or an executor's owner, is on the sanctions list: the co-signer registers, co-signs and refunds nothing for it (it reads its own copy of the list)
`REFUND_GAS`	a plain transfer to the owner can't be estimated (the wallet's code refuses it)
`EXECUTOR_CLOSED`	the executor's gas was refunded: it trades, signs and registers sessions no more
`CHAIN_UNAVAILABLE`	the co-signer couldn't read the chain itself: nothing was signed
`BUSY`	too many requests at once: retry

Hosted agents#

Code	Status	Meaning
`TOO_MANY_AGENTS`	429	at most 20 hosted agents per wallet
`BAD_TERMS`	422	the agent's risk terms contradict themselves
`BAD_SESSION`	422	the session can't drive this agent; every reason is in the message
`OUTSIDE_SESSION`	422	the agent's limits or terms are wider than its session's
`PAPER_AGENT`	409	a paper agent has no session or executor
`STOPPED`	409	a stopped agent can't change or resume
`STOP_FIRST`	409	stop a live agent before deleting it, or before its executor's gas goes back
`KILLED`	409	the kill switch is engaged
`LIVE_DISABLED`	409	live trading is off on this server
`SESSION_NOT_ACTIVE`	409	the attached session isn't active
`NO_EXECUTOR`	409	paper agents have no executor
`SESSION_ACTIVE`	409	a session for the agent's executor can still be co-signed: revoke it before its gas goes back
`STOCK_ATTESTATION`	422	the stock attestation isn't the agent's owner's signature over exactly this agent, executor, session, issue time and expiry, or it was issued more than an hour ago (or the signing service refused it)
`STOCK_ATTESTATION_OLD`	409	the stock attestation wasn't issued after the agent's last one or last revocation: sign a new one (`stock_attestation_not_before` on the agent says from when)
`BAD_EXPIRY`	422	the stock attestation must end at least 5 minutes from now, no later than the session and at most 30 days away
`SESSION_MISMATCH`	409	the stock attestation names another session than the one attached
`TOKEN_STOCK`	422	a stock token for a paper agent: only a live agent trades stock tokens, under your attestation
`SIGNED_MISMATCH`	502	the signing service's refund isn't exactly a plain transfer from the executor to you: nothing was relayed
`NOT_A_REFUND`	422	the relay refuses anything but a signed plain transfer from the executor to its owner
`NOT_WEBHOOK`	409	the agent's brain isn't a webhook
`EXECUTOR_ATTESTATION`	503	the executor's attestation couldn't be had from the signing service
`HOSTED_UNAVAILABLE`	503	hosted agents aren't running on this server
`NOT_AI`	409	the agent's brain isn't an AI model (no spend to show)

Inside a running agent, a held order is logged with its own code rather than answered as an error: for example STOCK_ATTESTATION (a stock token, and no valid attestation from you for this session), MARKET_CLOSED (a stock token outside the US stock-token session), STOCK_UNREAD (whether a token is a stock token couldn't be read), RISKS_MISSING, FEE_CLASS (the plan's fee class isn't the agent's own reading), FEE_MISMATCH (a fee its terms don't allow), SHIELD_MISMATCH, MIN_OUT_QUOTE, MIN_OUT_FLOOR, HELD_IMPERSONATOR, TOKEN_STALE, TOKEN_BLOCKED, SESSION_TOO_LONG, PAIR and LIVE_OFF. They are in the agent's logs.

An AI agent's tick that makes no call logs a hold: AI_BUDGET (its day's budget is spent), AI_OFF (the server can't call a model), AI_SHARE_SPENT or AI_POOL_SPENT (your share of Orblivion's credits, or the day's pool, is used and you haven't signed in with Orbio to continue on your own balance), AI_NOT_ELIGIBLE (a paper agent past its owner's trial, or a wallet the trial isn't open to), AI_NOT_LIVE (a live agent whose wallet hasn't yet traded the live share's minimum through Orblivion over the last days, or paid no trading fees on those trades, which back the share), AI_POOL_MODEL or AI_POOL_INTERVAL (Orblivion's credits pay only for the cheap models and 15-minute ticks, and a few of a wallet's calls each 15 minutes), AI_POOL_OFF, AI_POOL_UNAVAILABLE, POOL_AGENT or POOL_NOT_LIVE (the co-signer has no record of the agent yet, or no active trading session for the wallet), NOT_CONNECTED or DISCONNECTED (sign in with Orbio again), CONNECT_ERROR (Orbio refused Orblivion's app for a moment; your sign-in is kept), OWN_DAY_CAP, ORBIO_BALANCE, ORBIO_BUSY, ORBIO_RATE or AI_LATE (too little of the tick's time was left for a model call). Decisions paid by your own balance carry pool_hold with the reason Orblivion's credits didn't pay. An answer it refuses logs an error, and nothing trades that tick: AI_MALFORMED (not one JSON object), AI_SCHEMA (other fields than asked), AI_TOKEN (a token outside the agent's pairs), AI_PAIR (not one of its pairs), AI_SIZE (outside 1 to the per-trade limit) or AI_TOO_MANY (more orders than allowed); so does a call that failed (ORBIO_TIMEOUT, ORBIO_GATEWAY_ERROR, ORBIO_UNREACHABLE, ORBIO_UNAVAILABLE, ORBIO_REJECTED, MODEL_NOT_ALLOWED, COST_BOUND). A call that may have run without an answer (ORBIO_TIMEOUT, ORBIO_GATEWAY_ERROR, or the co-signer's answer lost) counts its worst-case cost against the agent's budget.

The league#

Code	Status	Meaning
`NOT_AN_AGENT`	404	the Orbio vault has no agent with that id
`NOT_OWNER`	403	the signed-in wallet isn't the agent's owner and no valid statement signed by the owner came with the entry
`STATEMENT_EXPIRED`	400	the statement's nonce is unknown, used or older than 10 minutes: ask for a new one
`STATEMENT_MISMATCH`	400	the statement was made for another wallet, agent, board or entrant
`AGENT_ENTERED`	409	the Orbio agent is already on that board (one entry per agent on each board)
`ALREADY_ENTERED`	409	this trading wallet, account or hosted agent already plays on that board for an agent: leave first
`PRIZE_IS_LIVE`	409	the prize league counts a trading wallet's real trades: a hosted paper agent plays the practice board, and a hosted live agent's trades count through its owner's wallet
`LEAGUE_DIVISION`	409	the account trades another division than the practice board's
`LEAGUE_PAPER_ONLY`	409	only paper hosted agents play the practice board
`LEAGUE_PAIRS`	409	on the practice board a hosted agent trades only ETH, cbBTC and ORBIO against USDG
`LEAGUE_INTERVAL`	409	a hosted practice entrant ticks at most every 300 seconds, the board's division limit
`NOT_ENTERED`	404	that entrant isn't in the league
`NO_SEASON`	404	no such season on record
`LEAGUE_UNAVAILABLE`	503	the league isn't running here, or the Orbio vault couldn't be read: retry shortly

A prize entry made without the owner's eligibility confirmation (its owner entered by signing in, or entered before the prize statement carried it) answers confirmed: false: it plays, and its CONFIRMED rule keeps it from a prize until the owner signs the prize statement and the entrant sends it to POST /api/v1/league/confirm. No refusal code goes with it. An entry with an address on the sanctions list fails its SANCTIONS rule, and can't be made at all (SANCTIONED).

A practice entrant's paper order between seasons is refused as SEASON_CLOSED, with why (a prize entrant's real trades are never held by the league). A hosted practice entrant's tick logs a hold rather than an error when its season's book isn't open: SEASON_CLOSED, LEAGUE_BOOK_PENDING, LEAGUE_UNAVAILABLE, or LEAGUE_PAIR for an order that isn't against USDG.

Raised by the SDKs#

The SDKs check every answer before anything is signed, and raise their own errors without calling the server:

Error	Code	Meaning
Verification error	`VERIFICATION_FAILED`	something the server returned failed a local check; `rule` names it (for example `RECIPIENT`, `FEE_CLASS`, `FEE_BPS`, `MIN_OUT`, `PRICE`, `QUOTE_OWN`, `IMPACT_OWN`, `RISK_CODES`, `RISK_NOT_ACCEPTED`, `V4_HOOKS`, `GRANT_BINDING`, `GRANT_CAPS`, `EXECUTOR_ATTESTATION`). Nothing was signed.
Fast mode can't take it	the reason	with `fallback` off, a fast trade that would fall back raises instead: `FAST_PAIR`, `STALE` (the warm state is older than its bounds), `APPROVAL` (no ERC-20 approval to Permit2 yet), `POOL_FAR` (the pool trades further under the SDK's Chainlink marks than its fee and the pair's band, 75 or 125 bps), `ROUTE_CAP` (the trade is over the pinned route's own size cap), `MARKS_DIFFER` (the SDK's RPC's marks are more than 3% from Orblivion's), `COOLDOWN` (the pair was refused on price moments ago), `CONFIG_MISMATCH`, or the server's refusal
Hash mismatch	`HASH_MISMATCH`	the server answered another hash than the signed transaction's
Config mismatch	`CONFIG_MISMATCH`	the server's config disagrees with what the SDK pins, or doesn't publish the disclosure contract
Mined mismatch	`MINED_MISMATCH`	the mined transaction, its output or the fee isn't what was signed
Reverted	`TX_REVERTED`	the transaction was mined and reverted; only gas was spent
Consent required	`CONSENT_REQUIRED`	a session grant that changes the wallet's code needs `allow7702`
Insufficient funds	`INSUFFICIENT_FUNDS`	the wallet can't pay the value and the gas
API error	the server's code	the server refused; `code` is one of the codes above, `HTTP_<status>` when the answer had none
Account answer	`ACCOUNT_SHAPE`	an answer of `client.me` (`GET /api/v1/me/*`) isn't of the shape the SDK expects: a field missing, of another type or out of its bounds
Account wallet	`ACCOUNT_WALLET`	an answer of `client.me` is for another wallet than the client's: it is ignored
League statement	`LEAGUE_STATEMENT`	the league statement the server asks to have signed isn't the SDK's own rebuild of it (the agent, the entrant, the wallet, the eligibility confirmation): nothing was signed
Signing mismatch	`SIGNING_MISMATCH`	the client was asked to sign a text that isn't this wallet's own prize league statement (or, in TypeScript, its stock attestation): nothing was signed