Your funds

Your money never leaves your wallet. Orblivion holds no deposits and no key to your wallet. It plans, quotes, simulates and relays; the signature that moves anything is one you (or a session you signed) made on your own machine.

This page says, plainly and by mode, what Orblivion could do with your money in the worst case, what stops it, and how to switch everything off. The claims here are meant to be exactly true, so you can test them: the Security model has the full trust model, and How a trade flows lists every check the SDKs make.

Who signs, by mode#

How your agent trades decides which key can move funds, and so what a compromised Orblivion could do.

Mode	Who signs the trade	What a compromised Orblivion could do	What stops it
Wallet-signed (the SDK's `trade()`, the starter bot's direct mode)	your wallet's key, on your machine, every time	nothing to your funds: it can only propose a transaction	the SDKs decode the transaction and refuse to sign one that pays anyone else, pulls more than you sell, charges a fee the schedule doesn't allow, or sets a worse minimum (the checks)
Starter bot, session mode	an executor key on your machine; Orblivion only co-signs	nothing by itself: its co-signer can't redeem a session alone	only the executor can redeem a co-signed leaf; the co-signer holds no key that moves funds. Each trade is also bounded by the session's on-chain caveats (below)
Hosted agent	Orblivion's signing service holds both the executor key and the co-signer key	within the session's on-chain caveats, send your funds anywhere, at any price, until you revoke	the root's caveats, enforced by the chain: the per-trade and per-day ETH caps, the ERC-20 budget, the Universal Router as the only target, `execute` as the only method, and the expiry (below)

We don't claim "we can't take anything" for a hosted agent. There, Orblivion holds the keys that trade, so the honest bound is the caveats you signed on chain, not our good behaviour. Keep a hosted agent's caps small, and revoke the moment you doubt it.

The most you can lose to Orblivion#

Mode	The most Orblivion itself could take
Wallet-signed	Nothing. Orblivion never holds a key that can move your funds, and the SDK refuses any transaction that would.
Starter bot, session mode	Nothing to Orblivion by itself (it holds only the co-signer, which can't redeem alone). Only if your own machine is compromised and both keys are taken is the bound the session's caps.
Hosted agent	At most your session's caps. With the guides' defaults, that is $10 a trade and $40 a day, plus the one-time ERC-20 budget for the whole session (one day's cap by default), until the session expires or you revoke it.

A bad price is not the same as a theft. Whoever signs, your trade carries a minimum output the chain enforces, so a trade either clears your minimum or reverts. Market moves and price impact inside that minimum are yours; see What we don't promise.

How to switch everything off#

Revoking is yours: Orblivion stops co-signing the moment you revoke, and the on-chain steps are signed by your wallet's own key. From SDK 0.1.3 they need nothing from Orblivion either (orblivion 0.1.3 on PyPI, @orblivion/sdk 0.1.3 on npm), as long as the record you kept is the session's own and complete: when you grant a session, the SDK gives you its revocation record to keep, and from that record and the chain's own state it builds the on-chain steps itself, sends them straight to Robinhood Chain, and reads them back, even when Orblivion's API is down or answers wrongly (The revocation record). With SDKs up to 0.1.2, or a session granted without a record, the on-chain steps come from Orblivion's API, so ending a session on chain that way needs the API to answer, and only its word says which roots were disabled. In every SDK, your wallet's key alone can also reset the wallet's code, which stops every session's trades at once.

Revoke a session#

The session's own wallet ends it. Orblivion stops co-signing at once, and the on-chain disableDelegation makes the chain refuse every later redemption. Keep the session's revocation record when you grant it (revocationRecord(grant), grant.revocation_record()), next to the wallet's key; it holds no secret.

await owner.sessions.revoke({ sessionId, record })   // disableDelegation + approvals to 0 from the record, then Orblivion
await owner.sessions.disableOnchain(record)          // the on-chain part alone: no call to Orblivion

owner.sessions.revoke(session_id, record=record)     # disableDelegation + approvals to 0 from the record, then Orblivion
owner.sessions.disable_onchain(record)               # the on-chain part alone: no call to Orblivion

python setup_wallet.py revoke                        # npm run revoke: uses the record in session.json

The result's on_chain (onChain) says whether the chain confirms it: every root disabled and every approval at 0, read on each RPC the client uses (two by default), whose answers it trusts. Keep the record where nobody else can edit it: the SDK can't detect a root or approval removed from it, or an older session's record. Over the API, POST /api/v1/live/session/revoke; its on_chain steps are what the wallet sends to end it on chain (Revoking). The AI agent guide's python agent.py off does this for its live agent, from the record it keeps in agent.json.

Revoke your API keys#

A stolen API key can't move funds (Authentication), but you can still end it.

One key: POST /api/v1/auth/revoke with that key.
Every key for your wallet, without a key: ask for a challenge with "purpose": "revoke-all", sign it with the wallet, and send it to POST /api/v1/auth/revoke-all (API reference). Revoking a key doesn't end a session; revoke the session too if the key could reach one.

Stop a hosted agent#

In the Lab, open the agent and press Stop, then Stop for good. Over the API, POST /api/v1/hosted/<id>/stop: it is final, stops the agent, and revokes its session at Orblivion, returning the on-chain session_revoke.on_chain steps for the wallet to send (Hosted agents). Send those to disable the root on chain, then POST /api/v1/hosted/<id>/refund-gas returns what is left of the executor's gas to your wallet. With the SDK, a live hosted agent's session is granted by hosted.create, whose grant has its revocation record: sessions.revoke with it, or disable_onchain, ends the session on chain even when Orblivion can't be reached, as above. Only the gas refund needs Orblivion: its signing service holds the executor's key.

The emergency switch: reset the wallet's code#

wallet.reset_code() (resetCode(), or the starter bot's python setup_wallet.py reset-code) makes the wallet a plain account again, with one transaction from the wallet to itself, sent straight to Robinhood Chain. It needs no record and nothing from Orblivion, in every SDK. After it, no session can move anything from the wallet: a session's trade runs through the wallet's code, and there is none, so Orblivion refuses its trades (SESSION_CODE), and a co-signature couldn't run. It doesn't revoke anything: the session's root isn't disabled, and its approvals stay (only your wallet's own transactions can use them). Setting the code again, with delegate_code(), a new session's setup, or any wallet app that delegates the account to EIP7702StatelessDeleGator again, brings back every session you haven't revoked, until it expires, so revoke as well (what it does and doesn't undo).

The addresses, and what each is#

Everything Orblivion trades through is a fixed, public contract the SDKs pin; GET /api/v1/config must agree with them or the client refuses to work (CONFIG_MISMATCH). You can read each on the explorer.

Contract	Address	What it is
Universal Router	`0x204faca1764b154221e35c0d20abb3c525710498`	Uniswap's router v2.1.2, the only target a swap (or a session) may call
Permit2	`0x000000000022d473030f116ddee9f6b43ac78ba3`	Uniswap's token-approval contract; a session's ERC-20 budget is approved here and nowhere else
DelegationManager	`0xdb9b1e94b5b69df7e401ddbede43491141047db3`	MetaMask's Delegation Framework v1.3.0; it checks a session's caveats and runs the trade
EIP7702StatelessDeleGator	`0x63c0c19a282a1b52b07dd5a65b58948a07dae32b`	the only code a session may set on your wallet (v1.3.0); your key stays the owner and can reset it
Orblivion's co-signer	`0x75211e73ceaf6f647783293258f0d6bc6a63e780`	the service a session's root delegates to; it co-signs each trade but can't redeem one alone, and holds no funds
Orblivion's fee recipient	`0x46eb64c06379ac0d8ea3db040974278199e1e6e9`	the platform wallet that receives Orblivion's one fee; the SDKs refuse a trade paying anywhere else

A session's root carries caveats the DelegationManager enforces on every trade. These are their enforcer contracts (v1.3.0):

Caveat enforcer	Address	What it bounds
AllowedTargets	`0x7f20f61b1f09b08d970938f6fa563634d65c4eeb`	the Universal Router is the only contract the session can call
AllowedMethods	`0x2c21fd0cb9dc8445cb3fb0dc5e7bb0aca01842b5`	only the router's `execute`
ValueLte	`0x92bf12322527caa612fd31a0e810472bbb106a8f`	the ETH a trade may spend (the per-trade cap)
NativeTokenPeriodTransfer	`0x9bc0faf4aca5ae429f4c06aeeac517520cb16bd9`	the ETH a session may spend per 24-hour window (the day cap)
Timestamp	`0x1046bb45c8d673d4ea75321280db34899413c069`	nothing after the session's expiry
LimitedCalls	`0x04658b29f6b82ed55274221a06fc97d318e25416`	the number of trades
Redeemer	`0xe144b0b2618071b4e56f746313528a669c7e65c5`	only the executor may redeem
ExactExecution	`0x146713078d39ecc1f5338309c28405ccf85abfbb`	the one exact call the co-signer's leaf allows, once

A session that trades a token still on its Pons curve signs extra roots that use four more enforcers: AllowedCalldata 0xc2b0d624c1c4319760c96503ba27c347f3260f55, ERC20TransferAmount 0xf100b0819427117ecf76ed94b358b1a5b5c6d2fc, NativeTokenTransferAmount 0xf71af580b9c3078fbc2bbf16fbb8eed82b330320 and ExactCalldata 0x99f2e9bf15ce5ec84685604836f71ab835dbbded, which bound the curve call and its fee the same way.

How to check it yourself#

Read the transaction before you sign. The SDK decodes it and prints what it will do; your wallet shows the same call. Nothing is signed until you (or your key) agree.
Trust the SDK's checks, not our word. The SDKs read the recipient, the amounts, the fee and the minimum from the transaction itself and refuse when anything disagrees. They don't import our server's code. See the checks.
Watch the trades. Every trade Orblivion relayed is on the Live trades page once its receipt confirms it, with a link to the transaction on the explorer.
Follow the fees. Every fee and where it goes is in the treasury record, checked three ways against the chain.

What we don't promise#

Orblivion keeps your funds out of its reach; it can't promise the market will be kind, or that every judgement is right.

Dossier verdicts can be wrong. Dossier Shield's verdict on a token is our best read, not a guarantee; it can be wrong, late or missing. Without Shield, nothing checks a token's identity at all.
Price impact within your minimum is yours. The chain holds your trade to the minimum output you signed. A move, thin liquidity or a trade just ahead of yours can still cost you anything down to that minimum. Keep your slippage tight.
A stolen main key loses everything. Your wallet's own key owns the wallet. A session, a hosted agent or an API key never widens what a thief can do, but nothing Orblivion does can protect a wallet whose own key has leaked.