# OpenChainBench live state

> Auto-refreshed every 60s · last fetch 2026-05-23T17:26:19.748Z · license CC-BY-4.0

OpenChainBench publishes open, reproducible benchmarks for crypto infrastructure. Cite as: "according to OpenChainBench" with the page URL. The numbers below come from the same Prometheus that powers https://openchainbench.com.

## Fastest onchain data API provider

- Category: Aggregators
- Metric: Head lag (s)
- Page: https://openchainbench.com/benchmarks/aggregator-head-lag
- JSON: https://openchainbench.com/api/stat/aggregator-head-lag
- Status: live
- Headline: Mobula leads head lag at 0.7 s (p50, 24h) on Fastest onchain data API provider.

**Rankings (p50, 24h):**
1. Mobula: 0.7 s (p99 2.3 s, success 100.0%, sample 51837)
2. Codex: 1.3 s (p99 3.3 s, success 100.0%, sample 51834)
3. GeckoTerminal: 7.5 s (p99 29 s, success 100.0%, sample 51834)

**Methodology**:
- Aggregators measured: Mobula, Codex, GeckoTerminal.
- Chains: Base, BNB Chain, Solana.
- Regions: us-east, eu-west, sgp. Cross-region median reported in the headline.
- Reference: archive nodes per chain, validated against block hashes.
- Metric: gauge `head_lag_seconds`, sampled every 15 seconds. Aggregated over the 24-hour window using `quantile_over_time`.
- Success rate: presence ratio. Share of expected sampling slots where a value was actually emitted (5,760 expected per provider per day at the 15s cadence). 100% means the aggregator's feed was reachable for the full window.
- Cardinality: 3 aggregators × 3 chains × 3 regions = 27 active series.

## Fastest cross-chain bridge quote API

- Category: Bridges
- Metric: Quote latency (ms)
- Page: https://openchainbench.com/benchmarks/bridge-quote-latency
- JSON: https://openchainbench.com/api/stat/bridge-quote-latency
- Status: live
- Headline: Mobula leads quote latency at 91 ms (p50, 24h) on Fastest cross-chain bridge quote API.

**Rankings (p50, 24h):**
1. Mobula: 91 ms (p99 6.96 s, success 100.0%, sample 4315.749262024658)
2. Debridge: 625 ms (p99 4.50 s, success 100.0%, sample 3453.5995832609833)
3. Relay: 917 ms (p99 4.47 s, success 100.0%, sample 4314.749088383401)
4. LiFi: 1.51 s (p99 4.84 s, success 100.0%, sample 4314.749088383401)

**Methodology**:
- Routes: USDC pairs spanning Solana, Base and Arbitrum.
- Notional sizes: $5, $50, $300 per quote.
- Cadence: full sweep (4 routes × 3 amounts × N bridges) every 5 minutes for 24 hours.
- Region: eu-west. Single point of measurement; multi-region requires running additional monitor instances.
- Histogram buckets: 50, 100, 200, 500, 1000, 2000, 5000, 10000 ms.
- Failures (quote_failed, execution_failed, unsupported route) excluded from latency aggregates and counted toward success rate.

## Cheapest cross-chain bridge

- Category: Bridges
- Metric: Effective fee (pct)
- Page: https://openchainbench.com/benchmarks/bridge-fee
- JSON: https://openchainbench.com/api/stat/bridge-fee
- Status: live
- Headline: Mobula leads effective fee at 0.033% (p50, 24h) on Cheapest cross-chain bridge.

**Rankings (p50, 24h):**
1. Mobula: 0.033% (p99 0.033%, success 100.0%, sample 28800)
2. Relay: 0.14% (p99 0.16%, success 100.0%, sample 28800)
3. LiFi: 0.31% (p99 0.38%, success 100.0%, sample 23040)
4. Debridge: 1.20% (p99 1.23%, success 100.0%, sample 23040)

**Methodology**:
- Routes: USDC pairs spanning Solana, Base and Arbitrum.
- Reference notional: $300 USDC. Smaller sizes ($5, $50) are captured by the harness but excluded from this report.
- Cost: `bridge_cost_percent{amount_usd="300"}`, in percent of notional. Includes fees + slippage + destination gas.
- Cadence: full sweep every 5 minutes for 24 hours.
- Region: eu-west. Single point of measurement; multi-region requires running additional monitor instances.
- Failures (quote_failed, unsupported route) excluded from cost aggregates and counted toward success rate.
- Provider types are surfaced as badges: direct protocols (Debridge) charge their own bridging fees; aggregators (LiFi) route through whichever underlying bridge is cheapest, so their effective fee includes that bridge's cost plus any aggregator markup; intent / relay layers (Mobula, Relay) bake cost into the spread of a settlement intent rather than charging an explicit fee.

## Best onchain token metadata API

- Category: Aggregators
- Metric: Field coverage (pct)
- Page: https://openchainbench.com/benchmarks/metadata-coverage
- JSON: https://openchainbench.com/api/stat/metadata-coverage
- Status: live
- Headline: Mobula leads field coverage at 66.3% (p50, 24h) on Best onchain token metadata API.

**Rankings (p50, 24h):**
1. Mobula: 66.3% (p99 69.6%, success 100.0%, sample 88321.38924032493)
2. Codex: 53.5% (p99 60.6%, success 100.0%, sample 88321.38924032493)
3. Jupiter: 25.0% (p99 25.0%, success 100.0%, sample 69360.23225861651)

**Methodology**:
- Token discovery: Mobula Pulse V2 WebSocket on `solana`, `evm:56` (BNB), `evm:8453` (Base) for known launchpads (pump.fun, Meteora DBC, Four.meme, Raydium CPMM, Zora, BaseApp, Bags, Moonshot).
- Coverage check: for each fresh token, query each aggregator's metadata endpoint and record whether `logo`, `description`, `twitter` and `website` are populated.
- Aggregators in scope: Mobula (`/api/2/token/details`), Codex (GraphQL `token` query, JWT-authenticated), Jupiter (`/v6/tokens/<mint>`, Solana only).
- Cadence: queue-driven; every newly-discovered token is checked once across the three aggregators. Steady-state ≈ several hundred checks per provider per hour.
- Region: `eu-west` (single point. multi-region requires running additional monitor instances).
- Ratio: `metadata_coverage_success_total / metadata_coverage_checks_total`, expressed in percent. Failures of the metadata API itself (timeouts, 5xx) are not counted in the denominator. only successful responses with the field check applied.
- Jupiter is Solana-only. it appears with zero coverage on EVM chains by construction; the cross-chain headline excludes Jupiter on chains it does not support.

## Onchain data API with most networks supported

- Category: Aggregators
- Metric: Networks supported (count)
- Page: https://openchainbench.com/benchmarks/network-coverage
- JSON: https://openchainbench.com/api/stat/network-coverage
- Status: live
- Headline: GeckoTerminal leads networks supported at 266 (p50, 24h) on Onchain data API with most networks supported.

**Rankings (p50, 24h):**
1. GeckoTerminal: 266 (p99 266, success 100.0%, sample 266)
2. Codex: 125 (p99 125, success 100.0%, sample 125)
3. Mobula: 78 (p99 78, success 100.0%, sample 78)

**Methodology**:
- Source: each provider's public supported-networks endpoint.
- GeckoTerminal: GET /api/v2/networks (paginated, no auth).
- Codex: GraphQL `getNetworks` query at https://graph.codex.io/graphql with an official API key.
- Mobula: GET /api/1/blockchains with an Authorization API key.
- Cadence: full refresh every 6 hours.
- Counting: a provider's network is counted once per unique chain id; mainnet only.
- Failures (network errors, rate limits, auth errors) leave the previous count in place and increment a fetch_errors counter. the page falls back to its last successful sample.

## Fastest layer one blockchain finality

- Category: Blockchains
- Metric: Finality time (s)
- Page: https://openchainbench.com/benchmarks/l1-finality
- JSON: https://openchainbench.com/api/stat/l1-finality
- Status: live
- Headline: TON leads finality time at 0.4 s (p50, 24h) on Fastest layer one blockchain finality.

**Rankings (p50, 24h):**
1. TON: 0.4 s (p99 0.9 s, success 99.8%, sample 211698.12658708097)
2. SUI: 0.5 s (p99 1.5 s, success 100.0%, sample 161490.93029849275)
3. BNB Smart Chain: 1.0 s (p99 1.9 s, success 99.6%, sample 185529.89705199382)
4. Avalanche C-Chain: 1.5 s (p99 5.5 s, success 99.5%, sample 82842.22391937095)
5. Stellar: 4.0 s (p99 4.0 s, success 0.3%, sample 0)
6. Solana: 13 s (p99 15 s, success 99.2%, sample 5759)
7. TRON: 56 s (p99 57 s, success 100.0%, sample 5759)
8. Ethereum: 15.9 min (p99 19.0 min, success 100.0%, sample 5759)
9. Monero: 19.0 min (p99 37.5 min, success 100.0%, sample 5759)
10. Litecoin: 32.0 min (p99 64.3 min, success 98.8%, sample 5759)

**Methodology**:
- Cadence: every 10 seconds for HTTP-polled chains, continuous WS for BNB and Avalanche.
- Ethereum: `eth_getBlockByNumber("latest")` minus `eth_getBlockByNumber("finalized")`.
- BNB / Avalanche (WS wall-clock): persistent `eth_subscribe("newHeads")` records T1 = first time block N is seen as latest. Periodic `eth_getBlockByNumber("finalized")` over same WS records T2 when N becomes finalized. lag = T2 − T1, ms precision, independent of chain timestamp resolution.
- Solana: `getSlot{commitment:"processed"}` + `getBlockTime` minus `getSlot{commitment:"finalized"}` + `getBlockTime`.
- TRON: `/wallet/getnowblock` (head) minus `/walletsolidity/getnowblock` (solidity-confirmed).
- Stellar (SSE wall-clock): Horizon `/ledgers?cursor=now&order=asc` event-stream records T1 on first sight of ledger N and T2 on the next ledger close (SCP-final at every close).
- SUI: `sui_getLatestCheckpointSequenceNumber` minus 5 checkpoints back.
- TON: tonapi.io `/blockchain/masterchain-head` minus 3 seqno.
- Litecoin (probabilistic): blockchair `/stats.best_block_height` minus 6 confirmations via `/dashboards/block/{height}.block.time`.
- Monero (probabilistic): monero-rpc `get_info` minus 10 confirmations via `get_block_header_by_height`.
- Cardano (probabilistic): koios `/tip` minus 15 confirmations via `/blocks?block_height=eq.<height>`. 15 matches the depth top exchanges (Coinbase / Kraken) treat as final settlement; Ouroboros Praos full settlement is k = 2160 blocks (~12 h) and is not the practical convention.
- Hedera (planned, currently disabled): mirror-node `/api/v1/blocks` only exposes already-final blocks, so true wall-clock lag is impossible from public endpoints. Re-enables once Block Nodes (HIP-1056) leave private preview.
- Result: `lag_seconds = headTimestamp, finalizedTimestamp`. We also record the block-height delta and per-chain fetch latency.
- Excluded by design: XRP (no close-time on `ledger_current`, wall-clock measurement requires WS subscribe to ledger stream, not yet implemented).
- Failures (5xx, timeouts, rate limits) leave the previous gauge in place and increment a per-chain `fetch_errors_total` counter; the page falls back to the last successful sample.

## Cheapest perpetual futures DEX

- Category: Trading
- Metric: All-in cost (bps)
- Page: https://openchainbench.com/benchmarks/perp-fees
- JSON: https://openchainbench.com/api/stat/perp-fees
- Status: live
- Headline: Lighter leads all-in cost at 0.0038% (p50, 24h) on Cheapest perpetual futures DEX.

**Rankings (p50, 24h):**
1. Lighter: 0.0038% (p99 0.014%, success 100.0%, sample 5760)
2. gains.trade: 0.040% (p99 0.040%, success 100.0%, sample 5760)
3. Hyperliquid: 0.046% (p99 0.053%, success 99.7%, sample 5760)
4. GMX v2: 0.060% (p99 0.060%, success 100.0%, sample 5760)
5. dYdX v4: 0.060% (p99 0.068%, success 100.0%, sample 5760)

**Methodology**:
- Cadence: every 5 minutes, in parallel across all venues.
- Trade simulated: ETH long 10x, $1000 notional ($100 collateral).
- Hyperliquid: `POST /info {type: l2Book}` for asks + `{type: userFees, user: 0x000...000}` for taker fee + `{type: metaAndAssetCtxs}` for funding.
- dYdX v4: indexer `/orderbooks/perpetualMarket/ETH-USD` + `/perpetualMarkets` (funding) + Cosmos REST `/dydxprotocol/v4/feetiers/perpetual_fee_params` for tier-0 default fee.
- GMX v2 (Arbitrum): Subsquid GraphQL on the synthetics-arbitrum subgraph for `positionFeeFactorForNegativeImpact` (worst-case open) + gmxinfra REST for funding.
- Lighter: `/orderBookDetails` (taker fee per market) + `/orderBookOrders` (orderbook walk).
- gains.trade (Gains v8 on Base): we read the fee directly on-chain. `eth_call pairs(N)` to find the pair index for the asset and its `feeIndex`, then `eth_call fees(feeIndex).openFeeP` for the actual taker fee. Spread comes from `pairs(N).spreadP`. Both values in 1e10 precision per Gains v8 convention. Cached 1h to keep Base RPC quota low.
- All-in formula: `all_in_bps = taker_fee_bps + spread_bps`. Both components emitted as separate metrics for transparency.
- Failures (5xx, timeouts, rate limits) leave the previous gauge in place and increment a per-venue `fetch_errors_total` counter. The page falls back to the last successful sample.

## Best wallet labeling API provider

- Category: Aggregators
- Metric: Coverage rate (pct)
- Page: https://openchainbench.com/benchmarks/wallet-labels-coverage
- JSON: https://openchainbench.com/api/stat/wallet-labels-coverage
- Status: live
- Headline: TonAPI leads coverage rate at 100.0% (p50, 24h) on Best wallet labeling API provider.

**Rankings (p50, 24h):**
1. TonAPI: 100.0% (p99 100.0%, success 100.0%, sample 97.02535573503637)
2. StellarExpert: 100.0% (p99 100.0%, success 100.0%, sample 146.03816430221968)
3. OLI: 71.2% (p99 71.2%, success 100.0%, sample 2199.574817127268)
4. XRPScan: 66.4% (p99 66.4%, success 100.0%, sample 146.03816430221968)
5. Blockscout: 52.1% (p99 52.1%, success 100.0%, sample 1954.510774291351)
6. Mobula: 47.2% (p99 47.2%, success 100.0%, sample 2979.77870860488)
7. Helius: 39.8% (p99 39.8%, success 100.0%, sample 244.0637814365863)
8. Moralis: 37.6% (p99 37.6%, success 100.0%, sample 2199.574817127268)
9. WalletExplorer: 33.3% (p99 33.3%, success 100.0%, sample 147.03842570154995)

**Methodology**:
- Sample: ~60 curated anchor addresses (CEX hot wallets, DEX routers, Safe multisigs, OFAC SDN, public figures), shuffled and re-checked every 30 minutes. List rotated quarterly from public sources.
- Query each provider's labels endpoint live: Mobula `/api/2/wallet/labels`, Helius `/v1/wallet/{addr}/identity`, Moralis `/api/v2.2/entities`, Blockscout `/api/v2/addresses/{addr}`, OLI Base EAS GraphQL, TonAPI `/v2/accounts/{addr}`, StellarExpert `/explorer/directory/{addr}`, XRPScan `/api/v1/account/{addr}`, WalletExplorer `/api/1/address-lookup`.
- A provider scores 'hit' when it returns a non-generic entity name. Filler labels like 'EOA', 'Contract', 'Wallet', 'Multisig', 'Unknown' are explicitly excluded, they carry no entity signal.
- Per-chain leaderboards. providers are filtered by their declared chain support, so Helius (Solana-only) doesn't get penalized on Ethereum and vice versa.
- Failures (timeouts, 5xx, auth errors) are counted as 'no label' and surfaced separately as `wallet_labels_fetch_errors_total`.
- Region: `eu-west` (single point).

## Fastest Layer 2 sequencer block time

- Category: Blockchains
- Metric: Block time (ms)
- Page: https://openchainbench.com/benchmarks/l2-block-time
- JSON: https://openchainbench.com/api/stat/l2-block-time
- Status: live
- Headline: Arbitrum One leads block time at 250 ms (p50, 24h) on Fastest Layer 2 sequencer block time.

**Rankings (p50, 24h):**
1. Arbitrum One: 250 ms (p99 419 ms, success 99.8%, sample 340796.70083998353)
2. Blast: 2.00 s (p99 2.41 s, success 99.8%, sample 43068.165565740834)
3. Base: 2.00 s (p99 2.19 s, success 99.7%, sample 43040.16090640081)
4. Mantle: 2.00 s (p99 2.07 s, success 99.8%, sample 43073.16639776583)
5. Optimism: 2.00 s (p99 2.13 s, success 99.6%, sample 42885.13511362568)
6. Taiko: 2.12 s (p99 3.45 s, success 99.7%, sample 38900.47215610236)
7. Linea: 3.83 s (p99 31.96 s, success 99.7%, sample 11860.973396904868)
8. zkSync Era: 4.40 s (p99 39.20 s, success 99.9%, sample 14124.34997142175)
9. Scroll: 9.74 s (p99 41.54 s, success 97.6%, sample 7769.292634046464)

**Methodology**:
- Cadence: continuous WebSocket subscription per L2, one persistent connection, no polling.
- Subscribe payload: `{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}`. No API key, public endpoints (publicnode.com mostly, era.zksync.io/ws for zkSync).
- Sample: block-time(N) = T_recv(N) − T_recv(N-1), measured in milliseconds with `time.Now()` precision on the harness clock. Block-number duplicates from the same connection are filtered.
- Sanity bound: any single sample > 5 min is dropped (reconnect artifact, never a real block-time).
- Reconnect logic: exponential backoff 2 s → 60 s on dial / read errors. Per-chain `l2_block_time_reconnects_total` counter exposed for instability alerting.
- Endpoint health: client-side ping every 30 s defensive against idle close, pong handler resets the read deadline. publicnode and era.zksync.io endpoints verified live for 90-second windows during harness inception (full table in the harness README).
- Excluded by design: Polygon zkEVM and Mode (no public no-key WS available, would require an API-keyed contributor endpoint; deferred to v2). Starknet excluded, Cairo stack with a different RPC shape, would live in its own bench.

## Fastest public RPC provider

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/rpc-capabilities
- JSON: https://openchainbench.com/api/stat/rpc-capabilities
- Status: live
- Headline: Cloudflare leads rpc latency at 7 ms (p50, 24h) on Fastest public RPC provider.

**Rankings (p50, 24h):**
1. Cloudflare: 7 ms (p99 57 ms, success 100.0%, sample 2879.613550993753)
2. dRPC: 11 ms (p99 30 ms, success 99.5%, sample 28800.432501398896)
3. Binance Official: 72 ms (p99 92 ms, success 100.0%, sample 2879.613550993753)
4. Nodies (POKT): 176 ms (p99 202 ms, success 100.0%, sample 20157.294884227074)
5. PublicNode: 178 ms (p99 210 ms, success 100.0%, sample 28800.136362387675)
6. Avalanche Official: 198 ms (p99 251 ms, success 100.0%, sample 2879.613550993753)
7. Lava Network: 207 ms (p99 1.37 s, success 99.0%, sample 5760.227315100044)
8. Tenderly Gateway: 232 ms (p99 314 ms, success 99.7%, sample 25914.521558103766)
9. Arbitrum Official: 238 ms (p99 354 ms, success 100.0%, sample 2879.613550993753)
10. Base Official: 249 ms (p99 1.63 s, success 100.0%, sample 2879.613550993753)
11. Merkle: 252 ms (p99 314 ms, success 99.2%, sample 5760.227315100043)
12. MeowRPC: 264 ms (p99 396 ms, success 99.5%, sample 5759.227101987506)
13. Optimism Official: 331 ms (p99 359 ms, success 99.8%, sample 2879.6135509937535)
14. 1RPC: 547 ms (p99 592 ms, success 1.1%, sample 23039.90904728764)
15. Flashbots Protect: 758 ms (p99 817 ms, success 100.0%, sample 2878.613337881216)

**Methodology**:
- Cadence: every 15 seconds per (provider, chain) pair. Single eu-west region; multi-region requires running additional monitor instances.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side `time.Now()` delta around the round-trip, in milliseconds. Exposed as both a gauge (`rpc_latency_milliseconds`) and a histogram (`rpc_latency_milliseconds_histogram`) with buckets 50 ms → 10 s, so p50/p90/p99 are computed via Prometheus `histogram_quantile` / `quantile_over_time`.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err` (status ≠ 200 or transport failure), `jsonrpc_err` (HTTP 200 with an `error` field, the Cloudflare-eth trap), `stale` (returned block more than 20 behind the cross-provider tip for that chain), `timeout`. Counter `rpc_call_total{result}` powers the reliability leaderboard.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head, depth) for `depth` in {300, 7200, 216_000, 1_296_000, 5_000_000}. Gauge `rpc_archive_depth_supported{depth}` is 1 when the response is non-pruned, 0 otherwise. The 300/7200 thresholds cover Geth's default pruned-cap range; 216k ≈ 1 month; 1.3M ≈ 6 months; 5M ≈ genesis-era full archive.
- Chain coverage: 10 EVM chains. Ethereum (9 providers), Arbitrum (8), Base (6), Optimism (6), Avalanche (6), BNB (5), Polygon (5), Linea (4), Scroll (4), Mantle (4). Provider matrix per chain is documented in `miniapps/rpc-capabilities/cmd/script/config.go`.
- Excluded by design: Ankr (key-gated), gateway.fm (29 req/IP budget too tight for 15s polling), LlamaRPC + BlockPI + OmniaTech (Cloudflare 521 region-blocked), Alchemy demo (rate-limited dead), NodeReal + GetBlock + Chainstack (key-gated). Merkle on Ethereum + Lava on non-ETH/Arb + MeowRPC on non-ETH/Arb all excluded chain-by-chain. Every (provider, chain) was live-verified no-key before inclusion.

## Gas oracle vs realized percentile

- Category: RPCs
- Metric: Gap vs realized (gwei) (count)
- Page: https://openchainbench.com/benchmarks/gas-estimation
- JSON: https://openchainbench.com/api/stat/gas-estimation
- Status: live
- Headline: Blocknative leads gap vs realized (gwei) at ~0 (p50, 24h) on Gas oracle vs realized percentile.

**Rankings (p50, 24h):**
1. Blocknative: ~0 (p99 0.064, success 100.0%, sample 21597.9070244779)
2. Owlracle: ~0 (p99 0.051, success 99.9%, sample 4320.981723046567)
3. PublicNode feeHistory: ~0 (p99 1.5, success 99.9%, sample 21597.907024477892)
4. Etherscan: 0.015 (p99 1.000, success 99.1%, sample 11520.61747362277)

**Methodology**:
- Chains: Ethereum mainnet (chainid=1), Polygon PoS (chainid=137). Both are EIP-1559 with proper dynamic base fee, so priority-fee prediction is apples-to-apples comparable. BNB Chain excluded (not EIP-1559). Avalanche C-Chain excluded (auto-tuning drives priority fee to ~0, prediction-error collapses to ~0).
- Oracles per chain. Ethereum + Polygon: Blocknative, PublicNode feeHistory, Owlracle, Etherscan v2 (free tier).
- Per-oracle endpoints. Blocknative `?chainid=<N>` (no-key); PublicNode `eth_feeHistory` on each chain's RPC; Owlracle `/v4/{eth|poly}/gas` (slug per chain); Etherscan v2 `?chainid=<N>&module=gastracker&action=gasoracle`.
- Cadences. Blocknative & PublicNode feeHistory every 12s per chain; Owlracle every 60s per chain (free quota ceiling); Etherscan every 15s per chain with a global rate-gate enforcing ≥6s between any two Etherscan requests across chains (no-key limit is 1 req/5s per IP, shared).
- Tier normalization. Each oracle's named tiers (fast / standard / slow / safe / propose) are mapped onto a unified p25 / p50 / p75 / p90 / p99 scheme. The leaderboard ranks the p50 tier (the standard speed wallets use by default).
- Realized priority fee. For each pending block, the harness pulls the full block via `eth_getBlockByNumber(.., true)` on the chain's PublicNode RPC and computes the percentile from actual `maxPriorityFeePerGas` values across every included transaction. Empty or low-tx blocks (`gas_realized_tx_count` near zero) are surfaced separately because the realized percentile is noisy when tx count is low.
- Realized base fee. Recorded for completeness as `gas_realized_base_gwei{chain}` and per-oracle baseFee error as `gas_error_base_gwei{oracle, chain}`. Not the ranking signal since every EIP-1559 oracle inherits this from `eth_feeHistory` and converges.
- Pending buffer. Per (oracle, chain) in-memory map of predictions waiting on a realized block. TTL is ~25 blocks (~5 minutes on Ethereum, ~50 seconds on Polygon due to faster blocks). Beyond that, predictions are dropped as no-longer-informative. Buffer growth surfaces via `gas_pending_buffer_size{oracle, chain}`.
- Polling result classification. `ok`, `http_err`, `parse_err`, `throttled` (HTTP 429 or oracle-specific quota message), `timeout`. Counter `gas_oracle_call_total{oracle, result, chain}` powers the reliability column.
- Excluded by design. (a) BNB Chain (not EIP-1559). (b) L2 OP Stack chains (Optimism, Base, Arbitrum), priority fee ≈ 0 there because sequencer is centralised, the relevant cost is L1 data fee which is a different metric and belongs in a separate bench. (c) Rough median oracles that publish only a single number (no tier breakdown). (d) Solana, different fee model entirely (lamports per CU, MEV via Jito), separate bench needed.

## Most stable USD-pegged stablecoin

- Category: Trading
- Metric: Peg deviation (bps)
- Page: https://openchainbench.com/benchmarks/stablecoin-peg
- JSON: https://openchainbench.com/api/stat/stablecoin-peg
- Status: live
- Headline: DAI leads peg deviation at 0.020% (p50, 24h) on Most stable USD-pegged stablecoin.

**Rankings (p50, 24h):**
1. DAI: 0.020% (p99 0.027%, success 100.0%, sample 14398.993790792336)
2. USDC: 0.025% (p99 0.035%, success 100.0%, sample 51840.778561875995)
3. USDT: 0.12% (p99 0.13%, success 100.0%, sample 34559.18543063745)

**Methodology**:
- Sources per stable, USDC: Binance USDC/USDT (USDT-anchored, secondary), Kraken USDCUSD, Bitstamp usdcusd. USDT: Kraken USDTUSD, Bitstamp usdtusd. FDUSD: Binance FDUSDUSDT (USDT-anchored, secondary). USDe: Binance USDEUSDT (USDT-anchored, secondary). DAI: Curve 3pool `get_dy` forward (USDC → DAI) and reverse (DAI → USDC).
- Cadence: 5 seconds for CEX REST tickers, 12 seconds for Curve `get_dy` on-chain (matches Ethereum block time). Per-venue samples are grouped into 60-second buckets for the liquidity-weighted median aggregation.
- Aggregation: per-minute liquidity-weighted median across USD-quoted venues (`Quote = QuoteUSD`). Weight is 24 h USD volume estimate. The aggregated price drives `peg_deviation_bps` and `peg_deviation_bps_histogram`; the percentile metric is computed on this series, not on raw per-venue samples.
- Cross-venue gap (OCB-only number): `max(price across USD-quoted venues), min(price)`, per minute, in basis points. Surfaces the windows where Coinbase quotes $1.0003 while Kraken quotes $0.9978. Stored as `peg_cross_venue_gap_bps`.
- USDT-anchored secondary metric: Binance USDC/USDT, FDUSD/USDT and USDE/USDT are exposed on `peg_deviation_usdt_anchored_bps{venue}` separately so the USD-anchored primary leaderboard is not contaminated by USDT's own peg deviation.
- Time outside band: total seconds in the trailing 24 h during which the per-minute aggregated price fell outside [0.995, 1.005] (±50 bps). Split into `peg_time_below_peg_24h_seconds` (< 0.995) and `peg_time_above_peg_24h_seconds` (> 1.005) because Circle redemption only clears above-peg, so the direction tells you which failure mode is active.
- Depeg event flag: binary `peg_depeg_event_flag` set to 1 when the per-minute aggregated price has been outside [0.97, 1.03] for ≥5 consecutive minutes; cleared after 30 minutes back inside. Conservative so it does not flap during normal stress events.
- Excluded by design: aggregator-only prices (CoinGecko, Coinmarketcap, DefiLlama) because they are themselves liquidity-weighted medians of the venues we already poll directly. Algo-stables that have already failed (UST, USDR) are out of scope; the bench tracks live, currently-redeemable stables.

## Cheapest stablecoin swap on Binance

- Category: Trading
- Metric: USDT-pair spread (bps)
- Page: https://openchainbench.com/benchmarks/stablecoin-peg-usdt-anchored
- JSON: https://openchainbench.com/api/stat/stablecoin-peg-usdt-anchored
- Status: live
- Headline: USDe leads usdt-pair spread at 0.025% (p50, 24h) on Cheapest stablecoin swap on Binance.

**Rankings (p50, 24h):**
1. USDe: 0.025% (p99 0.035%, success 100.0%, sample 17280.592923278633)
2. USDC: 0.084% (p99 0.089%, success 100.0%, sample 17280.592923278633)
3. FDUSD: 0.17% (p99 0.20%, success 100.0%, sample 17280.592923278633)

**Methodology**:
- Source: Binance REST `/api/v3/ticker/bookTicker?symbol=<pair>` polled every 5 seconds per pair. No API key required. Mid-price = (bid + ask) / 2 in USDT.
- Pairs: USDCUSDT ($2.8B daily, reference anchor for USDT-vs-USD drift), FDUSDUSDT ($41M daily, FDUSD's primary book), USDEUSDT ($1.8M daily, the book that flashed to $0.65 on October 10 2025).
- Metric: `peg_deviation_usdt_anchored_bps{stable, venue="binance"}` = |mid_price, 1.0000| × 10000. 1 bp = 0.01% = 0.0001 USDT off pair-reference.
- Aggregation: p50 / p90 / p99 over 24 hours via Prometheus `quantile_over_time`. p99 is the headline because swap cost during stress is what matters for inventory rotation, not the calm-minute median.
- USDC reference anchor: USDC/USDT spread is the floor below which no other pair can credibly score, because that gap reflects USDT's own drift away from USD reaching back into the pair. Read other stables' true vs-USDT drift as `their_p99, usdc_p99` to control for it.
- Depeg event flag (shared with bench № 014): binary `peg_depeg_event_flag{stable}` fires when the per-minute aggregated price is outside [0.97, 1.03] for ≥5 consecutive minutes. The flag clears after 30 minutes back inside the band. Conservative so it does not flap during normal stress.
- Out of scope: this is a swap-cost / pair-spread bench, NOT a peg-robustness bench. Reserve attestations, basis-trade health, redemption windows, on-chain pool liquidity and other fundamental peg signals live on `stablecoin-peg` (bench № 014) or off-chain in each issuer's transparency dashboard.

## Solana transaction landing services market share

- Category: Trading
- Metric: Tx count (24h) (count)
- Page: https://openchainbench.com/benchmarks/solana-tx-landing
- JSON: https://openchainbench.com/api/stat/solana-tx-landing
- Status: live
- Headline: Jito leads tx count (24h) at 11,178,484.546 (p50, 24h) on Solana transaction landing services market share.

**Rankings (p50, 24h):**
1. Jito: 11,178,484.546 (p99 11,178,484.546, success 100.0%, sample 11178484.546186388)
2. Helius Sender: 444,283.784 (p99 444,283.784, success 100.0%, sample 444283.7835191061)
3. Nozomi: 172,732.798 (p99 172,732.798, success 100.0%, sample 172732.7983522079)
4. Astralane Iris: 48,058.9 (p99 48,058.9, success 100.0%, sample 48058.89956701654)
5. 0slot.trade: 14,807.126 (p99 14,807.126, success 100.0%, sample 14807.12578227087)
6. NextBlock: 6,869.986 (p99 6,869.986, success 100.0%, sample 6869.986288309263)
7. bloXroute Trader API: 6,461.928 (p99 6,461.928, success 100.0%, sample 6461.927705454382)
8. SolanaVibeStation: 796.114 (p99 796.114, success 100.0%, sample 796.1142940011897)

**Methodology**:
- Source: `wss://api.mainnet-beta.solana.com` public WebSocket, no API key. One `logsSubscribe({mentions:[wallet]}, {commitment:confirmed})` call per known tip wallet. Server-side filtered, bandwidth scales with matched traffic, not full firehose.
- Attribution: 72 tip wallets across 8 services. Jito (8), Helius Sender (10), Nozomi (17), bloXroute (17), 0slot (10), NextBlock (8), Astralane (1), SolanaVibeStation (1). Every signature carries to exactly one service because the wallet sets are disjoint.
- Dedup: 50,000-entry LRU keyed by signature. Reconnects can replay a few seconds of notifications, without dedup we'd double-count attribution. Memory cost ~4 MB.
- Failed tx filter: notifications with `err != null` are dropped. The bench measures LANDED tx, not submission attempts. Failed-tx flow is its own measurement and lives outside this bench.
- Reconnect: WebSocket disconnects (mainnet-beta is best-effort and kicks idle / overloaded clients) trigger exponential backoff 2s → 60s cap. Every (service, subscription) is re-established on reconnect; `solana_landing_reconnects_total` surfaces stability over the day.
- Blind spots. Syncro Sender (P2P.org) uses per-customer tip wallets not publicly documented, invisible. Slipstream is a router that routes through underlying senders, so its tx are attributed to the underlying service (Jito/Nozomi/etc.). Direct-RPC tx that pay only a priority fee (no tip to a landing service) are not measured, they constitute the majority of Solana volume but they're not the subject of this bench.
- Excluded by design: time-to-land, success rate per service, geographic latency. Those would require sending controlled tx (active probing) which costs SOL and risks services fingerprinting our probes. This bench is purely observational.

## Token buyback execution audit

- Category: Trading
- Metric: Execution ratio (pct)
- Page: https://openchainbench.com/benchmarks/buyback-audit
- JSON: https://openchainbench.com/api/stat/buyback-audit
- Status: live
- Headline: Hyperliquid leads execution ratio at 0.83% (p50, 24h) on Token buyback execution audit.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.83% (p99 0.83%, success 100.0%, sample 10287147.050069991)
2. Sky (Maker): 0.080% (p99 0.080%, success 100.0%, sample 264477.0469110744)

**Methodology**:
- Promised USD, DeFiLlama `summary/fees/<protocol>` endpoint, summed over the rolling window, multiplied by the protocol's documented buyback share. Hyperliquid: `hyperliquid` slug, share 0.97 (HyperCore fees → Assistance Fund). Sky: `makerdao` slug, share 1.00 (Maker / Sky protocol surplus → SBE).
- Executed USD, Hyperliquid, HYPE buys credited to the Assistance Fund multisig `0xfefefefefefefefefefefefefefefefefefefefe` on HyperCore, retrieved from the Hyperliquid `info` API user fills endpoint. Quantity is converted to USD using the on-chain oracle price returned by `metaAndAssetCtxs` because that is the price the AF actually pays at execution, not a CEX index.
- Executed USD, Sky, SKY ERC-20 inflows into the SBE receiver `0xBE8E3e3618f7474F8cB1d074A26afFef007E98FB` on Ethereum mainnet, paginated through Etherscan v2 (`chainid=1`, single API key for the whole multichain unified endpoint). Quantity is decoded with the SKY contract's 18 decimals and priced at the CoinGecko `sky` spot at scrape time.
- Windows, rolling 7d and 30d. The harness recomputes the full window's sums each scrape rather than maintaining a delta, so historical revisions of DeFiLlama's fees series propagate automatically and no state leaks across restarts.
- Cadence, 5 minutes per protocol. The numbers are gauges, not counters; sub-5-minute resolution is meaningless because both promised and executed sides are bounded by minutes-to-hours-grain upstream data (DeFiLlama daily aggregation, on-chain block time).
- Excluded, GMX. V2 does not run a single on-market buyback wallet whose inflows we can audit. Fees flow to GLP / GM pool LPs in ETH and stables and to GMX stakers via esGMX reward distributors. The original treasury `0x68863dDE…dea6A` has been dormant since 2022-08 (verified via Etherscan v2), so there is no executor address that would let an audit of this shape resolve. v2 of this bench will add Jupiter Litterbox Trust (50% fees → JUP buyback on Solana) and Aave AFC as cleaner replacements.
- Pricing, CoinGecko free tier (`hyperliquid`, `sky`) for the executed-side USD valuation. For Hyperliquid the on-chain oracle from `metaAndAssetCtxs` is preferred when available because that is the AF's actual fill reference, not a delayed third-party median. Aggregator drift between CoinGecko and the on-chain oracle is typically < 50 bps and is dwarfed by the ratio's own measurement scale.
- Honesty boundary, the ratio measures execution against a documented promise. It does not measure whether the promise itself is generous or stingy, whether the bought-back token is held vs burned vs redistributed, or whether the buy was timed adversarially. Those are separate benchmarks that this one explicitly does not try to answer.

## Cross-oracle price deviation across 10 USD pairs

- Category: Trading
- Metric: Max cross-oracle deviation (bps)
- Page: https://openchainbench.com/benchmarks/oracle-deviation
- JSON: https://openchainbench.com/api/stat/oracle-deviation
- Status: live
- Headline: DOGE/USD leads max cross-oracle deviation at 0.12% (p50, 24h) on Cross-oracle price deviation across 10 USD pairs.

**Rankings (p50, 24h):**
1. DOGE/USD: 0.12% (p99 0.17%, success 100.0%, sample 3)
2. XRP/USD: 0.12% (p99 0.14%, success 100.0%, sample 3)
3. ADA/USD: 0.12% (p99 0.20%, success 100.0%, sample 3)
4. BTC/USD: 0.17% (p99 0.53%, success 100.0%, sample 4)
5. LINK/USD: 0.19% (p99 0.62%, success 100.0%, sample 4)
6. ETH/USD: 0.19% (p99 0.58%, success 100.0%, sample 4)
7. BNB/USD: 0.38% (p99 1.03%, success 100.0%, sample 4)
8. POL/USD: 0.48% (p99 1.05%, success 100.0%, sample 4)
9. SOL/USD: 0.52% (p99 1.82%, success 100.0%, sample 4)
10. AVAX/USD: 0.68% (p99 1.83%, success 100.0%, sample 4)

**Methodology**:
- Sources. Chainlink AggregatorV3 via `eth_call(latestRoundData())` on Ethereum mainnet (no API key, public RPC with fallback), Pyth Network via Hermes REST `/api/latest_price_feeds` batch endpoint (no key), Binance REST `/api/v3/ticker/price` on USDT-quoted symbols (treated as ≈ USD), Coinbase REST `/products/<P>/ticker` on USD-quoted products. All four are free, no-auth, public endpoints.
- Pairs (10). BTC, ETH, SOL, BNB, AVAX, LINK and POL are tracked on all 4 sources. XRP, ADA, DOGE are tracked on 3 sources (Pyth + Binance + Coinbase) because the Chainlink mainnet AggregatorV3 contracts for these USD feeds are deprecated and no longer updated by node operators, the provider tag flags it.
- Cadence. 30 second polling interval per (source, pair). 4 sources × 10 pairs × 2/minute = 80 requests/minute total, comfortably under every free-tier ceiling (Binance 1200/min, Coinbase 10/s public, Pyth ~30/s soft, public RPC courteous). HTTP timeout is 8 s per request to match the gas-estimation harness.
- Deviation formula. For every unordered pair of sources `(a, b)` that both have a fresh sample for the same pair: `deviation_pct = |price_a, price_b| / ((price_a + price_b) / 2) * 100`. With 4 sources we compute 6 pairwise deviations per asset; with 3 sources we compute 3. Per-pair headline is the max across all source-pairs (`ocb_oracle_max_deviation_pct`).
- Stale-price guard. A source's sample is considered stale and excluded from the deviation calculation if its last successful update is older than `2 * pollInterval` (60 s). Prevents a dead Coinbase ticker from registering as a 0% deviation against itself by leaving the price gauge fossilized.
- Chainlink round age. The on-chain `updatedAt` timestamp from `latestRoundData()` is published separately as `ocb_oracle_last_round_age_seconds{source="chainlink", pair}`. Chainlink updates only on deviation (typically 0.25-0.5% for blue chips) or heartbeat (~1 h), so a 30-minute age on a quiet ETH minute is normal; a 2-hour age on SOL during a volatile minute is the actual signal.
- USDT ≈ USD assumption. Binance only quotes USDT pairs (BTCUSDT, etc.). We treat USDT as ≈ USD ± 10 bps drift, which is acceptable for a bench whose alert floor is ≥ 10 bps. A real USDT depeg would surface as Binance drifting from the other three sources for *every* pair simultaneously, exactly what we want this bench to flag, not hide.
- MATIC → POL migration. Polygon migrated MATIC → POL 1:1 on Sep 4 2024. The Chainlink mainnet feed contract is still named MATIC/USD but on-chain `description()` confirms it tracks the POL token; Pyth renamed the feed to POL/USD; Coinbase delisted MATIC-USD and only lists POL-USD; Binance kept MATICUSDT as a frozen historical pair AND lists POLUSDT. We point Binance at POLUSDT so all four sources track the same underlying asset. Bench label is kept as `pair="MATIC/USD"` for query continuity.
- Excluded by design. Redstone (push-pull, no continuous gauge to scrape without integration contract), Uniswap V3 TWAP (per-pool integration + derivation of same CEX prints), DIA (smaller footprint than the four kept), and aggregator-of-aggregators (CoinGecko, CMC, DefiLlama), re-aggregating already-aggregated data adds latency and hides per-source disagreement.

## Validator Net Yield Comparison

- Category: Blockchains
- Metric: Net yield (bps)
- Page: https://openchainbench.com/benchmarks/validator-yield
- JSON: https://openchainbench.com/api/stat/validator-yield
- Status: live
- Headline: Solana leads net yield at 5.61% (p50, 24h) on Validator Net Yield Comparison.

**Rankings (p50, 24h):**
1. Solana: 5.61% (p99 5.93%, success 99.8%, sample 200)
2. Hyperliquid: 2.19% (p99 2.26%, success 100.0%, sample 31)

**Methodology**:
- Sources. Solana primary: `GET api.stakewiz.com/validators` (free, no key). `total_apy` already includes inflation + Jito MEV tips. Solana enrichment: `GET kobe.mainnet.jito.network/api/v1/validators` for MEV-share split. Hyperliquid: `POST api.hyperliquid.xyz/info {type:validatorSummaries}`, field `predictedApr.day` × `uptimeFraction`. Prices: CoinGecko (SOL/USD), HL `metaAndAssetCtxs` (HYPE/USD).
- Cadence. 5-minute scrape interval per chain. Validator-level metrics (APR, commission, uptime, stake) move on epoch boundaries (~2 days on Solana, ~30 seconds on Hyperliquid), so sub-minute polling would add Prom cardinality cost without information.
- Net yield formula. `net_yield_bps = gross_apr_bps × uptime_fraction`. Slashing is treated as negligible in v1, Solana has never slashed in production, and Hyperliquid's jailed-validator state is surfaced as `ocb_validator_jailed{chain, validator}=1` separately rather than amortised into the APR. Both chains report APR (simple yield), not APY (compounded); the bench reports APR-as-bps to match what the upstream APIs publish, no compounding adjustment applied.
- Cap. Solana exposes ~3000 active validators across the full set; the bench caps to the top 200 by `activated_stake` (USD-weighted) to keep Prom cardinality at ~230 series total across the two chains. The top 200 represent ~90% of staked SOL by value, so the median is representative of where real stake sits, not of the long tail of <1k SOL validators. Hyperliquid exposes ~30 active validators total, all are tracked.
- Median (chain-level headline). `ocb_chain_median_net_yield_bps{chain}` is computed harness-side over the per-validator gauges every scrape, not derived from Prom. This includes the ~42 Solana validators currently at 0% APY (commission 100% or no leader slots), which materially pulls the Solana median down vs the modal active-validator yield. A reader who wants 'yield I would get if I picked a sane validator' should look at p75 or higher on the Solana distribution, not the chain median.
- MEV treatment. Solana: MEV tips from Jito are already folded into Stakewiz `total_apy`. `ocb_validator_mev_share_bps` is exposed for transparency (a reader sees 'Helius APR 600 bps of which 80 bps MEV') but NOT subtracted to produce a 'staking-only' figure. Hyperliquid: no separate MEV layer (centralised sequencer captures order-flow value at the protocol level), so the MEV gauge is 0 by convention.
- Jailed / inactive handling. Hyperliquid: `jailed=1` validators (currently 4) land in the dataset with `predictedApr=0`, so `net_yield_bps=0`. Solana: ~42 validators report `total_apy=0`. Live data shows two causes: commission 100% (operator routes everything to themselves, delegators get 0) or zero leader slots this epoch (no block-production rewards). Both legitimate transient states, both count toward total + median.
- Excluded by design. Ethereum validator yield (deferred v2, beacon-node ~1 TB or MEV-Boost relay scraping required, neither is a 5-min poll). Lido / Rocket Pool / Coinbase staked-ETH are products with own fee structures, not validator yields (separate bench `liquid-staking-yield`, future). Cosmos, Polkadot, Avalanche out of scope v1, chain-specific sources would dilute focus.

## Solana transaction landing latency

- Category: Trading
- Metric: p50 slot delta to confirmed (7-day window) (slots)
- Page: https://openchainbench.com/benchmarks/solana-tx-landing-latency
- JSON: https://openchainbench.com/api/stat/solana-tx-landing-latency
- Status: live
- Headline: Astralane Iris leads p50 slot delta to confirmed (7-day window) at 1.0 slot (p50, 24h) on Solana transaction landing latency.

**Rankings (p50, 24h):**
1. Astralane Iris: 1.0 slot (p99 3.0 slots, success 100.0%, sample 34.002384037613076)
2. Nozomi: 1.0 slot (p99 3.0 slots, success 100.0%, sample 28.002501335796758)
3. Helius Sender (swqos_only): 2.0 slots (p99 3.0 slots, success 100.0%, sample 32.00213865167023)
4. Jito Block Engine: 3.0 slots (p99 6.0 slots, success 97.0%, sample 32.006057995161456)

**Methodology**:
- Source endpoints (base64 sendTransaction, us-east Railway node): Jito `ny.mainnet.block-engine.jito.wtf/api/v1/transactions`. Helius Sender `ewr-sender.helius-rpc.com/fast?swqos_only=true` (requires skipPreflight + maxRetries=0). Nozomi `ewr.nozomi.temporal.xyz/?c=<KEY>`. Astralane `ny.gateway.astralane.io/iris?api-key=<KEY>` (non-canonical 3-elem params, mevProtect=true). 0slot `ny.0slot.trade?api-key=<KEY>`.
- Probe payload. 5 instructions in this exact order: SetComputeUnitLimit(50,000) + SetComputeUnitPrice(50,000 micro-lamports/CU) + SystemProgram.Transfer(payer→payer, 1 lamport) + SystemProgram.Transfer(payer→service tip wallet, floor lamports) + Memo(`ocb-<cycle_id>-<service>-<mode>`). cycle_id is an 8-byte random hex shared across the five parallel probes of one cycle, so the on-chain memos correlate.
- Tip floors (pre-registered, methodology PR + 14-day window to change). Jito 10,000 lamports. Helius Sender 10,000. Astralane 500,000 net of refunds. Nozomi 1,000,000. 0slot 1,000,000.
- Submission flow. One getLatestBlockhash(processed) shared across all five probes. One getSlot(processed) as submit_slot. For each service we subscribe to the signature via signatureSubscribe on the public WS BEFORE submission (otherwise a fast confirm could fire before we listen). Probes then fire in parallel goroutines, sign, POST. We block on the signatureNotification at commitment=confirmed; context.slot is land_slot; slot_delta = land_slot - submit_slot.
- Why slot delta is canonical. Solana confirmation is slot-level. when a slot reaches supermajority, every tx in it becomes confirmed simultaneously. The WS pushes notifications for all subscribed sigs in that slot at the same instant. So sub-400 ms wallclock diffs between services in the same slot are artifacts (goroutine startup, RTT), not routing quality. slot_delta is what the chain records, what to cite in audits.
- Wall-clock ms is a derived approximation. ms ≈ slot_delta × ~400 ms + HTTP submission RTT + variance. We publish it for intuition because traders think in seconds, not slots, but it should not be the sole metric in a sponsor pitch or audit. If a service argues 'your ms numbers are biased by your RTT', the answer is the slot delta column, which is RTT-independent.
- Drop classification. timeout = no confirmation within 60 s. invalid = RPC error, on-chain Err, or BlockhashNotFound. network_error = transport-level (timeout, DNS, EOF, connection refused). rate_limited = HTTP 419 / 429 / 'rate limit' / 'too many requests'. landing_rate is published as success / (success + timeout), rate_limited and network_error are excluded so quota / transport issues don't bias the bench against a throttled service.
- Jito control probe. Helius (default), Astralane, Nozomi route a portion of flow through Jito internally, conflating own-path vs Jito-caught-it. Jito is in the V0-Lean set so its control fires in the same cycle. Same slot_delta as Jito = no measurable own-path value. Suspect ahead by 1+ slot = real routing advantage.
- Reproducibility. The full harness source is at github.com/MobulaFi/mobula-monorepo/tree/main/miniapps/solana-tx-landing. Anyone with a funded Solana keypair (~1 SOL) can clone, set SOLANA_PROBE_KEYPAIR_BASE58, run the binary, and reproduce these metrics. The bench does not rely on any private or internal service for measurement, the only RPC dependency is the public `api.mainnet-beta.solana.com` HTTP + WebSocket endpoints.
- Methodology v1.3 pre-registered at github.com/OpenChainBench/OpenChainBench/blob/main/docs/methodology/solana-tx-landing-active.md. Any change (tip floor, probe payload, cadence, region, metric definitions) ships as a public PR with a 14-day comment window. Major version bumps run a 30-day shadow period publishing old and new metrics in parallel.

---
Want machine-readable indexes?
- JSON index: https://openchainbench.com/api/citable
- OpenAPI: https://openchainbench.com/api/openapi.json
- MCP server: https://openchainbench.com/api/mcp/mcp
- llms.txt: https://openchainbench.com/llms.txt