Trading terminal fill quality 2026: what a swap costs on Axiom, GMGN, FOMO, Photon, Trojan, measured on-chain

Each terminal takes its fee through known wallets. A live WebSocket feed of every transaction mentioning those wallets, with its program logs, says which ones attempted a swap and whether they failed; the harness counts them all (fail rate) and reads 1,000 successful ones per Solana row per day and 6,000 per EVM row, drawn at random. From the pre/post balances of every account in the transaction it derives, in quote units (SOL or a $1 stable), what left the user, what the pool received, what reached the terminal's fee wallets (on the EVM rows: the router's residual after the pool and the gas), the tx fee and the inclusion tips, and the rest (pump.fun protocol and creator fees, referral payouts). The pool is the vault pair of the swap instruction, by pubkey, so a hop through another pool of the same program is never mistaken for pool impact. The token leg is valued at the pool's mid before the swap: exactly from the pool's pre-trade balances in the transaction on PumpSwap (with the virtual quote reserve its migrated pools store) and Raydium, else at the effective price of the previous trade on the same pool, at most 60 seconds earlier. Loss = 1 − value received / value given, in basis points of the trade; terminal, network and other are exact and independent of the reference, pool is the remainder. Rolling 24 hour window, medians with a bootstrap interval, p90, trade size and venue mix per terminal; published from 50 priced swaps, ranked from 100.

• ·Effective sample: a pooled row is judged on Kish's (sum w)^2 / sum w^2 over its priced swaps' chain weights, not on the raw count. It needs 25 effective swaps to publish and 100 to be ranked, so a product whose flow concentrates on one chain reads provisional however many swaps it holds: Binance Wallet carries 227 priced for 62 effective. The count shown in the table is the raw one.
• ·Trade-size views: the same window split at $25 and $250 of trade value. Each bucket's figures are plain medians over its own swaps, where the All-sizes row weights each chain's median by its flow; inside one size bucket of one product there is no chain mix to correct for. Failed swaps and failure overhead stay blank under a size filter: a failed attempt never reached a pool and has no trade size. A bucket needs 20 priced swaps to publish and 40 to be ranked, so thin buckets read as provisional.
• ·Sampling: a WebSocket feed of every transaction mentioning each terminal's fee wallets (DeFiLlama adapters, Dune's spellbook: Axiom 22, GMGN 9, Trojan 6, Terminal 2, the others 1; pump.fun's app and Banana Gun also by program). The logs say whether a swap program was invoked: only those count as attempts, all of them for the fail rate; 1,000 successful ones per Solana row per day are read and 6,000 per EVM row, drawn at random, weighted by the tick's activity (clamped). Rolling 24 h.
• ·The user is the signer whose token balance moved; when nobody signed for the user (limit, DCA and auto-sell orders executed by the terminal's keeper), the wallet whose token account moved against its SOL / stable balance, never a program-derived pool address. Quote assets: SOL, USDC, USDT, USD1, USDS, PYUSD; token-to-token swaps are not measured.
• ·Quote side, exact from balance deltas: user_q = what left or reached the user's SOL / WSOL / stable balance, the tx fee and the deposit of new token accounts (~0.002 SOL each, network cost; a refund on close is not credited) included; pool_q = the pool's quote movement, in the user's quote unit; terminal_q = lamports, WSOL or stables landing in the fee wallets (FOMO: plus its user-signed USDC legs).
• ·network_q = tx fee if the user paid it + inclusion tips: Jito, 0slot, bloXroute, Astralane, Nozomi and each terminal's own relay accounts (Axiom, Trojan, Maestro, Photon, Pepeboost, pump.fun app). other_q = user_q minus pool_q, terminal_q and network_q on single-pool routes without hops (pump.fun protocol and creator fees, referral payouts); on routed swaps it stays inside pool.
• ·Pool identity: the token vault that moved against the user and the quote vault of the same swap instruction, both by pubkey. Two pools behind one shared authority (Raydium, Launchpad, Meteora DAMM v2) never merge, so a hop through a sibling pool is never read as pool impact and the previous-trade lookup only sees that pool.
• ·Reference price, in order, routed swaps included: the pool's exact pre-trade mid from its balances in the transaction (PumpSwap, Raydium); the venue's swap event when it carries the pre-trade state (Launchpad, DLMM) and reconciles with the vault deltas; else the previous trade on the pool, at most 60 s old (pump.fun curve, CLMM), up to 2 h on BasedBot's EVM launchpad curves. No off-chain token price; gas coins at Coinbase spot on Relay rows, at the route's hop mid on native EVM rows.
• ·Loss (headline): buy = 1 − tokens × ref / user_q; sell = 1 − user_q / (tokens × ref). Basis points of the trade (buy: quote spent; sell: tokens × ref; either plus the gas when the user paid it outside the quote asset). Pool = loss minus terminal, network and other: the components (relay on Relay rows) sum to the loss per swap; the split columns are medians (flow-weighted on All chains) and do not sum to the median loss. Losses outside −10 % to +50 % stay out. Median with its 95 % interval, p90.
• ·A product is published from 50 priced swaps in the window (a chain row, or a single-chain product, from 25) and marked as ranked from 100, a row with one side only and no fee on it waits, and a product waits while its main chain fills. The previous-trade reference carries the previous trader's direction, so terminals priced mostly that way read some tens of bps worse in buy waves than on the exact mid.
• ·Settlement time: the destination block's timestamp minus the origin block's, one definition on every route and both directions. Bridged trades and wallet-funding transfers are separate columns, never pooled: the figure is a per-route mean, so a route carrying only transfers would otherwise read faster for that alone. Ten settlements minimum per column, stalls over 60 s excluded; the count is published below that floor, so a route barely seen is not read as unmeasured.
• ·Fail rate: failed over every swap attempt the feed saw on the terminal's wallets in the window, exhaustive; wallet funding, fee sweeps and marker transfers invoke no swap program and are not attempts. Error classes are in the JSON. On the EVM rows the fail rate comes from a sample of blocks read in full (every transaction sent to the routers, reverted or not).
• ·Cost of failures: 40 failed attempts per terminal per day are read for the fee they paid (a failed transaction executes nothing but pays base + priority fee; zero when the terminal sponsors gas). Failure overhead = fail rate / (1 − fail rate) × median failed fee, in bps of the median trade: what a successful swap carries on average in wasted attempts. Published apart from the cost per swap, not added to it.
• ·PumpSwap's vault ratio alone is not the mid: pools migrated from pump.fun add a virtual quote reserve (about 17.6 SOL) that the pool account stores; with it x·y = k matches executed trades exactly. pump.fun's 2026 bonding curve fills 20 to 60 % above its stored virtual_sol / virtual_token, so the curve gets the previous-trade reference instead.
• ·Sandwiches: each sampled swap's neighbours on its pool are screened (another signer trading our direction in our slot just before, and back just after, closing a comparable position with a take). Kept per swap in the JSON with the attacker and both signatures, not published as a column: how many swaps can be screened depends on pool activity, so terminals are not comparable on it.
• ·Trade-size buckets (under $25, $25 to $250, over $250): median loss per bucket in the public JSON and on each product page, so terminals with different typical trade sizes are compared at equal size.
• ·One row per product; the chain selector shows the product on one chain (Solana and six EVM chains), All chains pools its swaps across chains (bridge funding legs stay out). Each chain is sampled at a fixed daily rate, so All chains weighs a chain's sampled swaps by its swap attempts per sample: the pooled figure follows the users, not the sampler. Published from 50 priced swaps pooled over the chains at 25 or more; it waits while the chain carrying most of the flow fills.
• ·Cross-chain (FOMO): the user pays on BNB, Robinhood Chain, Base, Ethereum or Arc and Relay delivers on Solana. Relay's public requests feed identifies the app's requests (fee address or referrer) with what the user sent in USD, the fees, both hashes and the status. Value received = what the settlement delivered on Solana: USDC / SOL exactly (FOMO funds the wallet this way; the token buy that follows is a native swap in the FOMO row) or a token at the pool's state before the swap.
• ·Cross-chain split: terminal = the app fee the user paid; network = origin gas plus the destination gas Relay charged (its fee breakdown); relay = Relay's fixed and price fees plus the solver's spread (deposit minus received minus app fee minus that gas); pool only when a token was delivered. A token sold on the origin chain is priced at that chain's pool state in its per-chain row. Refunds and failures count in the fail rate. Perps are not measured; swaps under $2 are dropped.
• ·Trading on another chain (FOMO on Robinhood Chain, BNB, Base, Ethereum, Arc): the user pays in USDC or SOL from the FOMO wallet, a Relay solver buys the token there. Value given = what was sent (tx fee inside); value received = the tokens delivered at the pool's state before the settlement swap: v2 forks from the Sync reserves minus the swap, v3 forks and Uniswap v4 from the price left by the previous swap on the pool, all from the pool's own logs on public RPCs.
• ·Which side of an EVM pool is the token is settled by matching the swap event's amounts with the receipt's transfers, not the pool's token order. Split: terminal = the app fee; relay = what Relay kept (fees, spread, gas); pool = the settlement swap's impact and LP fee; network = the Solana tx fee (0 when the app's sponsor signs). Sales the other way (a token sold on that chain, USDC or SOL delivered on Solana) sit in the same per-chain row, priced at the origin pool's state before the sale.
• ·FOMO sponsors gas: its own signer pays the tx fee out of the fee the user paid, so it reads as network cost and comes off the terminal fee; its fee is a router commission plus user-signed USDC legs, all counted as terminal fee. pump.fun's app forwards a fixed 0.001 SOL on some swaps, counted as network.
• ·Native EVM (GMGN and Axiom on BNB and Robinhood Chain, Banana Gun): their router contracts emit an event on every swap; eth_getLogs on those routers lists every successful swap they routed; the fail rate comes from a sample of blocks read in full (every tx sent to the routers, reverted or not). Value given = what the user sent plus gas; received = the tokens at the pool's state before the swap; the fee is paid inside the router as a native transfer: the residual after pool and gas.
• ·Unpriced draws: on the EVM rows a share of the drawn swaps (about a sixth on BNB; on Robinhood Chain 2 of 35 fills on 2026-09-21 once the launchpad curves and ETH-quoted v4 pools were decoded) cannot be valued at the pool's state and stays out of the figure; a token launch's first curve buy is its own reject (launch_first_trade), not a fill; each entry's unpriced_share and its rejects in the JSON say how much and why.
• ·Cohort discovery: the fee wallets and routers are learned from the chain, the lists being the seed. On a platform's transactions (Mobula's attribution as the sample, every 6 h), a recipient taking a fixed share of the trade across many payers is its fee wallet, adopted from 30 swaps of 20 payers with a stable 20 to 300 bps share; on EVM the transactions' destination is its router. The window's swaps also give the fee-like recipients no terminal lists yet (JSON, 'discovery').
• ·Phantom (Solana): its in-wallet swap pays 0.85 % to its fee wallet in SOL or WSOL, sampled like the other Solana terminals. Binance Wallet (BSC, Ethereum, Base): one router on the three chains, no event of its own, so its swaps are the transactions sent to it in blocks read in full; valued like the other native EVM rows. Terminal's EVM fee wallets get under $10 a day: not measured. Banana Gun on Ethereum: buys only, no fee, its users sell on Uniswap directly; held out (one side).
• ·four.meme's bonding curve on BNB is priced exactly: the curve is a constant product on virtual reserves (checked on consecutive trades to 1e-12), its constants come from the TokenManager's token info, so the mid before the trade is known; the launchpad's 1 % fee is 'other', like pump.fun's on Solana.
• ·Kept out of that residual: a fee the pool's own hook keeps (v4 launchpad pools on Robinhood Chain 1 %, BNB 3.8 %, paid whatever the router) is a pool cost; a native leg (BNB sent, ETH received) is valued at the mid of the route's own stable-to-gas-coin hop before that hop, so the hop's LP fee and impact stay a pool cost; Axiom's inclusion tip (0.0025 BNB fixed; on Robinhood Chain the user's setting, from the call trace) is network cost, like the Solana tip relays.
• ·BasedBot takes its 1 % fee inside the swap, through Jupiter: read on 2026-10-24, 30 of 30 transactions crediting its wallet invoke a swap program in the same transaction and none is a standalone transfer. It was read the other way until then, pairing each fee to the swap before it, which left the Solana row parsed but unpriced. Its fee is now the credit inside the swap, and its failed swaps are visible like any other app's.
• ·One row per route, not per app: pump.fun's cross-chain trades are published twice over, as Pump Bridge (its own routers, read on chain) and as the pump.fun app (what Relay still carries). Folding them together averaged two routes into a number describing neither, and the two differ in fee, settlement time and error rate. Relay draws the same split in its own published comparison.
• ·Pump Bridge's rows are grossed up: its router is paid out of pump's own liquidity, already net of the 0.05 plus 40 to 45 bps it keeps, so the spend is raised back to what the user committed before the loss is taken. Both parameters come from that chain's own spends: the fixed part from pairs at different trade sizes, which solve it assuming no value, and the rate from exact read-backs. A chain with too few falls back. Residual about 2.5 bps, against 45 to 545 bps of ignoring the deduction.
• ·Pump Bridge's sales are priced from the delivery, not a schedule: both legs of an order carry the same sixteen-byte id, in the router event's topic1 and in the Solana payout, so what the user received is read. A sale whose id is absent or whose delivery is not held stays unpriced. The join rate is published rather than stated here, because it measures a race: a sale is usually read before its delivery exists. While the priced and drawn side mixes differ by over 20 points the row is not ranked.
• ·pump.fun's app charges about 45 bps to KfHbT5Jr…, counted as terminal fee. That account was filed as a Pump Bridge sell-side route until 2026-10-24, when 25 transactions crediting it were read: 23 invoke a pump swap venue and none the bridge, so it is an app fee and the row no longer reads 0. Pump Bridge differs: its deduction is grossed onto the spend and lands in Terminal as a residual. A second flagged account is pump's gas sponsor, which PAYS on every swap, so read that 0 as unmeasured.
• ·Pump Bridge publishes no fail rate. Failures on this route do not show up as EVM reverts (0 in about 1,050 relayer transactions read on Robinhood Chain on 2026-10-22), and most of its swaps are sent to the user's own proxy rather than to the router, so a block sample of router transactions sees about 3 % of them (tfq_router_direct_total). Its error rate is not measurable from the chain here.
• ·MegaETH and X Layer are read but not shown: Pump Bridge's router is deployed on both and no bridge aggregator covers either, so this is the only measurement of them, but MegaETH has never executed a trade (relayer nonce 0) and X Layer had one priced swap on 2026-10-22. They get a chain tab when they carry enough trades to publish one; until then a tab would answer nothing.
• ·Not in the table: BullX (suspended June 2026), Nova (no live fee wallet), Bloom on Base and Ethereum (a swap an hour), Photon on EVM. BasedBot's Relay requests are its in-app bridge between the user's Solana and EVM wallets, both ways, no app fee (a bridge leg, not a trade); its EVM rows are those wallets' swaps on its router.