Fees and gas

Orblivion takes one fee, on chain, in the same transaction as your trade: 0.25% on majors, 0.50% on other tokens, and 0.10% more with Dossier Shield. There are no accounts, subscriptions or withdrawal fees. You pay the network's gas yourself.

Orblivion's fee#

• A major trade pays 0.25% (25 bps). The trading wallet's volume lowers it: 0.15% from $50,000 and 0.10% from $500,000 of trailing 30-day volume.
• Any other trade pays exactly 0.50% (50 bps), whatever the volume. Other trades have no volume tiers.
• Dossier Shield adds 0.10% (10 bps) to either: 0.35% on a major trade (or its tier plus 0.10%), and 0.60% on any other.

The server sets the fee for every request. A request can't set it or send it elsewhere: one that names a fee_bps is refused (FEE_FIXED). It can only cap it, with max_fee_bps (below).

Which trades are major#

A trade is major only when both of its ends, the token it sells and the token it buys, are majors:

• ETH, WETH, USDG, cbBTC or ORBIO, recognised by address;
• or a Robinhood stock token, such as NVDA or SPY, confirmed on chain: its proxy's beacon is the Robinhood stock tokens' beacon. Robinhood's published lists don't decide it; the chain does, for every party alike.

Every other trade is other: Orbio agent tokens, Pons and other launchpad tokens, tokens on a bonding curve and long-tail tokens. A curve token is always other.

• Only the trade's two ends count, never the hops between them. ETH to USDG is major whichever pools it passes through; ETH to an agent token is other.
• A token that copies a major's symbol at another address is other.
• The class is computed, never trusted. The server, both SDKs, the co-signer, the web app and hosted agents each read it themselves from the trade's two tokens. A plan whose fee_class differs from the client's own reading is refused (FEE_CLASS).

Which token pays the fee#

Orblivion takes its fee in ETH or USDG wherever it can. Each end of the trade is ranked, and the fee comes from the end that ranks higher:

When both ends rank the same, the fee comes from the output.

• From the input: the router receives the whole amount you sell, pays the fee from it first as a fixed amount, exactly floor(amount_in × bps / 10,000), and swaps the rest. An ETH fee is paid in native ETH.
• From the output: the router takes the fee's bps of what the swap returned, then sends you the rest.
• Either way your minimum output is what reaches your wallet, after the fee.
• Like the class, the side is computed, never trusted: the server, both SDKs, the co-signer, the web app and hosted agents each apply the rule themselves, and refuse a plan that takes the fee in another token or from the other side (FEE_TOKEN, FEE_SIDE), or out of its place (FEE_ORDER).

Volume tiers#

A major trade's tier comes from the trading wallet's trailing 30-day USD volume of trades Orblivion relayed (POST /api/v1/live/submit or fast mode) and saw mined: plans, session trades and hosted agents' trades, valued at trade time. Only Orblivion's books hold that number, so the tier is the server's.

Each trade counts what its major end moved, valued at an independent price, never at a token's own pool:

• the amount you sell when it is a major (ETH, WETH, USDG, cbBTC, ORBIO or a stock token), else the guaranteed minimum you receive when that is one;
• valued at $1 for USDG, Chainlink for ETH, WETH, cbBTC and the stock tokens, and for ORBIO the 30-minute average price of its Uniswap v3 ORBIO/WETH pool;
• a trade between two tokens that aren't majors counts nothing toward the tier.

A session trade the executor sends itself, not through Orblivion's relay, doesn't count: Orblivion never learns that it mined. The SDKs send session trades through the relay. A trade that doesn't count only leaves the wallet at a higher tier, never above the posted rate.

A client can't check the tier, so it accepts a major trade's fee only at one of the pinned tiers, and never above the posted rate (25 bps, or 35 with Shield):

The server can only discount. To refuse the posted rate, set a lower cap with max_fee_bps.

The fee in a plan#

Every plan says what it pays, at its top level and in fee. Every kind of plan follows the same rule: a router trade's fee command (TRANSFER from the input, PAY_PORTION from the output), a curve trade's fee transfer (batch and two-step), and each leg of a batch.

"fee_bps": 25, "fee_class": "major", "fee_tier": 25, "shield": false,
"fee_side": "input", "fee_token": "0x0000000000000000000000000000000000000000",
"fee": {"bps": 25, "side": "input", "recipient": "0x...", "token": "0x0000000000000000000000000000000000000000", "command": "TRANSFER", "amount": "2750000000000"}

A trade of an agent token or any other long-tail token by address is other: "fee_bps": 50, "fee_class": "other", "fee_tier": 50, or "fee_bps": 60 with Shield.

Capping the fee#

A request may name max_fee_bps: the most it will pay, in bps. A plan whose fee would be above it is refused (422 FEE_BPS). For example, "max_fee_bps": 25 takes a major trade without Shield at any tier, and refuses an other trade (50).

The SDKs take it as maxFeeBps (TypeScript) or max_fee_bps (Python), and check every plan against it before anything is signed.

In a session#

A session binds its fees when the owner signs it. Every new grant is binding version 4, which binds fees for the session's Shield mode:

Any other value is refused. The co-signer reads each leaf's class itself, from the leaf's two tokens and its own on-chain stock check, and ignores the server's. It co-signs a leaf only if its fee is allowed:

• a major leaf: one of the pinned tiers between major_min_bps and major_max_bps;
• an other leaf: exactly other_bps.

A curve token is always other, so a curve session's fee root caps its fee transfers at other_bps.

Sessions granted before schedule 2 (binding versions 1 to 3) keep schedule 1's one fee on every leaf until they expire: 10 bps for versions 1 and 2, and for version 3 its fee_bps, 10 or 15 with Shield. See Sessions.

How it is taken#

• Router trades. One command inside the Universal Router call pays the fee recipient, in the token the rule gives. From the input it is a TRANSFER of a fixed amount, exactly floor(amount_in × bps / 10,000), right after the router receives what you sell and before any swap. From the output it is a PAY_PORTION of the bps, after the last swap. Your minimum output applies after the fee.
  • The input's fee is a fixed amount because anyone can leave a few wei in the router, and a share of the router's balance would then be more than bps of what you sell. Your swap spends everything the router holds, so such dust goes to you.
  • On the output the fee is a share of everything the router holds after the swap, and every check of it counts from what the router paid out (you and the fee recipient).
• Curve buys. The curve has no fee parameter, so the fee is a transfer of floor(amount_in × bps / 10,000) of the input (ETH or ORBIO: they outrank the token), before the curve call: a separate transaction from a plain wallet (sent together with the trade; see Two-step curve trades), or the first call of the wallet's own atomic batch. A plan whose fee rounds to zero isn't built (FEE_TOO_SMALL).
• Curve sales. In the wallet's own atomic batch (or a session), the fee is the pair (ORBIO or ETH), a transfer after the sale of exactly floor(min_out × bps / 10,000), where min_out is the curve call's guaranteed minimum; the plan's amount_out_min is that minimum less the fee. From a plain wallet the sale is two transactions, and the fee is still the token sold, in the first one (fee_side: "input"): a fee sent after the sale could be skipped, and one sent before it would need pair tokens the wallet may not hold.
• Session trades. The same, under the co-signed leaf. The co-signer refuses any leaf whose fee its binding doesn't allow for the leaf's class, that pays it to anyone but the fee recipient, or that takes it in another token or from the other side.

The simulation reads the payment from the swap's own trace (simulation.fee_transfer, with exact: true when it is precisely the bps). A fee in native ETH has no Transfer log on chain: after mining, the SDKs report its amount from the signed calldata, which they check equals what was mined. From the input that is the fixed TRANSFER, so its amount is exact; from the output it is an estimate.

Who checks the fee#

To be sure the fee goes where you expect, pin the recipient in the client: expect: { feeRecipient } in TypeScript, expect={"fee_recipient": ...} in Python. A server whose config names another is then refused.

The schedule in the config#

GET /api/v1/config publishes the schedule under fee, and the SDKs refuse any difference from what they pin (CONFIG_MISMATCH):

"fee": {"schedule": 2,
        "major_symbols": ["ETH", "WETH", "USDG", "cbBTC", "ORBIO"],
        "major_tiers": [{"min_30d_volume_usd": 0, "bps": 25},
                        {"min_30d_volume_usd": 50000, "bps": 15},
                        {"min_30d_volume_usd": 500000, "bps": 10}],
        "other_bps": 50, "shield_add_bps": 10, "max_bps": 100,
        "recipient": "0x...", "...": "..."}

• major_symbols: the core majors, recognised by their pinned addresses (tokens). Robinhood stock tokens confirmed on chain are majors too.
• major_tiers: each tier's minimum trailing 30-day volume in USD, and its rate.
• other_bps and shield_add_bps: the rate for any other trade, and what Shield adds to either class.
• max_bps: no fee is ever above it.
• recipient: the address every fee goes to.

Schedule 2 replaces schedule 1's default_bps, bps and shield_bps, which are gone.

Gas#

Robinhood Chain's gas is cheap: the base fee sits near its floor, and a swap costs about one cent.

• Orblivion's plans offer no priority tip (there is no public mempool to compete in) and cap maxFeePerGas at twice the base fee; the gas limit is the simulated gas plus 30%.
• The SDKs refuse a transaction whose gas limit times its fee cap is over 0.0002 ETH.
• At $10 a trade, gas is about a tenth of a percent; above $100 it no longer matters.
• In a session, the executor pays the gas. For a hosted agent, fund its executor with about ten trades' worth.

What a trade costs in total#

A trade's cost is the pool's own fee and price impact, plus Orblivion's fee, plus gas. Measured on deep pools in October 2026, ETH and the stock tokens against USDG cost about 1 to 2 bps a side at $100 to $10,000 before Orblivion's fee, which is 0.25% on these major pairs (0.15% or 0.10% at higher volume). Thin tokens cost far more: an Orbio agent token still on its bonding curve pays the curve's 1% fee each way plus steep price impact, about 5% a side at $1,000, and Orblivion's 0.50% on top. Dossier Shield adds 0.10% to either. Every quote shows the route's cost (vs_mid_bps, gas_usd), its price impact and Orblivion's fee (fee_bps) before you trade.