From 8f51012fffe980e6a9a42051674ad92f51fa5e54 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Wed, 19 Aug 2026 01:06:04 +0200 Subject: [PATCH 1/2] feat(rpc): add 10 new chain benches 222-231 (Tezos/EOS/VeChain/Waves/WAX/Neon/Merlin/Viction/ThunderCore/OKTC) --- benchmarks/eos-rpc.yml | 135 +++++++++++ benchmarks/merlin-rpc.yml | 134 +++++++++++ benchmarks/neon-rpc.yml | 134 +++++++++++ benchmarks/oktc-rpc.yml | 134 +++++++++++ benchmarks/tezos-rpc.yml | 135 +++++++++++ benchmarks/thundercore-rpc.yml | 134 +++++++++++ benchmarks/vechain-rpc.yml | 135 +++++++++++ benchmarks/viction-rpc.yml | 134 +++++++++++ benchmarks/waves-rpc.yml | 134 +++++++++++ benchmarks/wax-rpc.yml | 135 +++++++++++ .../rpc-capabilities/cmd/script/config.go | 105 +++++++++ .../rpc-capabilities/cmd/script/probe.go | 217 +++++++++++++++++- src/data/provider-registry.ts | 138 +++++++++++ src/lib/brand.ts | 34 +++ src/lib/logo-manifest.ts | 21 ++ 15 files changed, 1858 insertions(+), 1 deletion(-) create mode 100644 benchmarks/eos-rpc.yml create mode 100644 benchmarks/merlin-rpc.yml create mode 100644 benchmarks/neon-rpc.yml create mode 100644 benchmarks/oktc-rpc.yml create mode 100644 benchmarks/tezos-rpc.yml create mode 100644 benchmarks/thundercore-rpc.yml create mode 100644 benchmarks/vechain-rpc.yml create mode 100644 benchmarks/viction-rpc.yml create mode 100644 benchmarks/waves-rpc.yml create mode 100644 benchmarks/wax-rpc.yml diff --git a/benchmarks/eos-rpc.yml b/benchmarks/eos-rpc.yml new file mode 100644 index 00000000..6b15005b --- /dev/null +++ b/benchmarks/eos-rpc.yml @@ -0,0 +1,135 @@ +# OpenChainBench. Bench No 223 + +slug: eos-rpc +number: "223" +title: Fastest free EOS RPC, live no-key endpoint latency +seo_title: "Fastest free EOS RPC 2026" +seo_description: "{{best_name}} leads free EOS RPC at {{best_p50}} (get_info head_block_num p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for GET /v1/chain/get_info against every available public EOS (Antelope) node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + EOS is a delegated proof-of-stake (DPoS) blockchain built on the Antelope protocol, producing one block every 0.5 seconds across 21 elected block producers. The chain provides a REST chain API under /v1/chain/ allowing standard queries without an API key. Public endpoints are available from Greymass, EOS Nation and Aloha EOS. Every provider was live-verified with consecutive get_info probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to EOS. + We measure the round-trip latency of a single REST call (GET + /v1/chain/get_info) against every available public EOS node that + sustains continuous probing: 3 providers at launch, every 60 + seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + an EOS-scaled staleness gap (600 blocks, around 5 min at 0.5 s/block). + The cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the EOS-scoped answer with per-region breakdowns as a + first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: HTTP GET /v1/chain/get_info. Plain REST call. The response carries head_block_num as a plain integer." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable head_block_num integer), http_err, jsonrpc_err, stale (block more than 600 behind the cross-provider tip), timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=eos. Provider coverage at launch: 3 endpoints (Greymass, EOS Nation, Aloha EOS)." + +findings: + - "{{best_name}} currently leads EOS RPC at {{best_p50}} (get_info head_block_num p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free EOS RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (EOS head block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which EOS RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Greymass (eos.greymass.com), EOS Nation (eos.api.eosnation.io) and Aloha EOS (api.main.alohaeos.com). Every listed endpoint was live-verified with a get_info call returning a parsable head_block_num before inclusion." + - q: "Does the fastest EOS RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is EOS RPC latency measured here, technically?" + a: "One GET /v1/chain/get_info REST call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="eos"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: greymass + name: Greymass + tag: Greymass public EOS mainnet Antelope API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/chain/get_info sent every 60s from 3 regions to eos.greymass.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="eos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="greymass", chain="eos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="greymass", chain="eos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="greymass", chain="eos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="greymass", chain="eos"}) / sum(ocb:rpc_call:rate_24h{provider="greymass", chain="eos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="greymass", chain="eos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="eos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="eos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="eos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="eos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="eos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="eos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="eos", region="sgp"}[1h]) + + - slug: eosnation + name: EOS Nation + tag: EOS Nation public EOS mainnet Antelope API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/chain/get_info sent every 60s from 3 regions to eos.api.eosnation.io." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosnation", chain="eos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="eosnation", chain="eos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="eosnation", chain="eos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="eosnation", chain="eos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="eosnation", chain="eos"}) / sum(ocb:rpc_call:rate_24h{provider="eosnation", chain="eos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="eosnation", chain="eos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="eosnation", chain="eos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosnation", chain="eos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="eosnation", chain="eos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosnation", chain="eos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="eosnation", chain="eos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosnation", chain="eos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="eosnation", chain="eos", region="sgp"}[1h]) + + - slug: alohaeos + name: Aloha EOS + tag: Aloha EOS public EOS mainnet Antelope API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/chain/get_info sent every 60s from 3 regions to api.main.alohaeos.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="alohaeos", chain="eos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="alohaeos", chain="eos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="alohaeos", chain="eos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="alohaeos", chain="eos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="alohaeos", chain="eos"}) / sum(ocb:rpc_call:rate_24h{provider="alohaeos", chain="eos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="alohaeos", chain="eos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="alohaeos", chain="eos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="alohaeos", chain="eos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="alohaeos", chain="eos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="alohaeos", chain="eos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="alohaeos", chain="eos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="alohaeos", chain="eos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="alohaeos", chain="eos", region="sgp"}[1h]) diff --git a/benchmarks/merlin-rpc.yml b/benchmarks/merlin-rpc.yml new file mode 100644 index 00000000..94e7952f --- /dev/null +++ b/benchmarks/merlin-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 228 + +slug: merlin-rpc +number: "228" +title: Fastest free Merlin Chain RPC, live no-key endpoint latency +seo_title: "Fastest free Merlin Chain RPC 2026" +seo_description: "{{best_name}} leads free Merlin Chain RPC at {{best_p50}} (eth_getBlockByNumber EVM p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for eth_getBlockByNumber against every available public Merlin Chain node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Merlin Chain is an EVM-compatible Bitcoin Layer 2 network (chain ID 4200) that uses ZK-Rollup technology to inherit Bitcoin security while enabling smart contracts and DeFi. It exposes a standard Ethereum JSON-RPC interface. Public EVM endpoints are available without an API key from Merlin Official, dRPC and Thirdweb. Every provider was live-verified with consecutive eth_getBlockByNumber probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Merlin Chain. + We measure the round-trip latency of a single eth_getBlockByNumber + ("latest", false) call against every available public Merlin Chain + node that sustains continuous probing: 3 providers at launch, every + 60 seconds, from us-east, eu-west and Singapore. The harness + classifies every response (ok / http_err / jsonrpc_err / stale / + timeout) with a standard EVM staleness gap. The cross-chain view + lives on the parent rpc-capabilities benchmark; this page is the + Merlin Chain-scoped answer with per-region breakdowns. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: {\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"eth_getBlockByNumber\",\"params\":[\"latest\",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable block number), http_err, jsonrpc_err, stale, timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=merlin. Provider coverage at launch: 3 endpoints (Merlin Official, dRPC, Thirdweb)." + +findings: + - "{{best_name}} currently leads Merlin Chain RPC at {{best_p50}} (eth_getBlockByNumber p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Merlin Chain RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Merlin Chain block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Merlin Chain RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Merlin Official (rpc.merlinchain.io), dRPC (merlin.drpc.org) and Thirdweb (4200.rpc.thirdweb.com). Every listed endpoint was live-verified with an eth_getBlockByNumber call returning a parsable block number before inclusion." + - q: "Does the fastest Merlin Chain RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is Merlin Chain RPC latency measured here, technically?" + a: "One eth_getBlockByNumber JSON-RPC call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="merlin"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: merlin-official + name: Merlin Official + tag: Merlin Chain official public RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to rpc.merlinchain.io." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="merlin-official", chain="merlin"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="merlin-official", chain="merlin"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="merlin-official", chain="merlin"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="merlin-official", chain="merlin"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="merlin-official", chain="merlin"}) / sum(ocb:rpc_call:rate_24h{provider="merlin-official", chain="merlin"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="merlin-official", chain="merlin"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="merlin-official", chain="merlin"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="merlin-official", chain="merlin", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="merlin-official", chain="merlin", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="merlin-official", chain="merlin", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="merlin-official", chain="merlin", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="merlin-official", chain="merlin", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="merlin-official", chain="merlin", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: dRPC decentralised multi-chain RPC, public Merlin Chain endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to merlin.drpc.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="merlin"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="merlin"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="merlin"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="merlin"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="merlin"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="merlin"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="merlin"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="merlin"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="merlin", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="merlin", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="merlin", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="merlin", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="merlin", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="merlin", region="sgp"}[1h]) + + - slug: thirdweb + name: Thirdweb + tag: Thirdweb public Merlin Chain RPC (chain 4200), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to 4200.rpc.thirdweb.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="merlin"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thirdweb", chain="merlin"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thirdweb", chain="merlin"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thirdweb", chain="merlin"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thirdweb", chain="merlin"}) / sum(ocb:rpc_call:rate_24h{provider="thirdweb", chain="merlin"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thirdweb", chain="merlin"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="merlin"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="merlin", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="merlin", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="merlin", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="merlin", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="merlin", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="merlin", region="sgp"}[1h]) diff --git a/benchmarks/neon-rpc.yml b/benchmarks/neon-rpc.yml new file mode 100644 index 00000000..2112957f --- /dev/null +++ b/benchmarks/neon-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 227 + +slug: neon-rpc +number: "227" +title: Fastest free Neon EVM RPC, live no-key endpoint latency +seo_title: "Fastest free Neon EVM RPC 2026" +seo_description: "{{best_name}} leads free Neon EVM RPC at {{best_p50}} (eth_getBlockByNumber EVM p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for eth_getBlockByNumber against every available public Neon EVM node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Neon EVM is an Ethereum Virtual Machine runtime that executes Solana-native transactions, allowing standard EVM smart contracts and wallets to operate on Solana infrastructure. It exposes a standard Ethereum JSON-RPC interface (chain ID 245022934) at multiple public endpoints. Public EVM endpoints are available without an API key from P2P Neon Proxy, Thirdweb and Everstake. Every provider was live-verified with consecutive eth_getBlockByNumber probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Neon EVM. + We measure the round-trip latency of a single eth_getBlockByNumber + ("latest", false) call against every available public Neon EVM node + that sustains continuous probing: 3 providers at launch, every 60 + seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + a standard EVM staleness gap. The cross-chain view lives on the + parent rpc-capabilities benchmark; this page is the Neon EVM-scoped + answer with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: {\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"eth_getBlockByNumber\",\"params\":[\"latest\",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0; Neon EVM exposes a full EVM-compatible interface." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable block number), http_err, jsonrpc_err, stale, timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=neon. Provider coverage at launch: 3 endpoints (P2P Neon Proxy, Thirdweb, Everstake)." + +findings: + - "{{best_name}} currently leads Neon EVM RPC at {{best_p50}} (eth_getBlockByNumber p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Neon EVM RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Neon EVM block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Neon EVM RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: P2P Neon Proxy (neon-proxy-mainnet.solana.p2p.org), Thirdweb (245022934.rpc.thirdweb.com) and Everstake (neon-mainnet.everstake.one). Every listed endpoint was live-verified with an eth_getBlockByNumber call returning a parsable block number before inclusion." + - q: "Does the fastest Neon EVM RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is Neon EVM RPC latency measured here, technically?" + a: "One eth_getBlockByNumber JSON-RPC call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="neon"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: neon-p2p + name: P2P Neon Proxy + tag: P2P.org public Neon EVM mainnet proxy, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to neon-proxy-mainnet.solana.p2p.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="neon-p2p", chain="neon"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="neon-p2p", chain="neon"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="neon-p2p", chain="neon"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="neon-p2p", chain="neon"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="neon-p2p", chain="neon"}) / sum(ocb:rpc_call:rate_24h{provider="neon-p2p", chain="neon"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="neon-p2p", chain="neon"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="neon-p2p", chain="neon"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="neon-p2p", chain="neon", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="neon-p2p", chain="neon", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="neon-p2p", chain="neon", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="neon-p2p", chain="neon", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="neon-p2p", chain="neon", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="neon-p2p", chain="neon", region="sgp"}[1h]) + + - slug: thirdweb + name: Thirdweb + tag: Thirdweb public Neon EVM RPC (chain 245022934), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to 245022934.rpc.thirdweb.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="neon"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thirdweb", chain="neon"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thirdweb", chain="neon"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thirdweb", chain="neon"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thirdweb", chain="neon"}) / sum(ocb:rpc_call:rate_24h{provider="thirdweb", chain="neon"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thirdweb", chain="neon"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="neon"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="neon", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="neon", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="neon", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="neon", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="neon", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="neon", region="sgp"}[1h]) + + - slug: everstake + name: Everstake + tag: Everstake public Neon EVM mainnet RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to neon-mainnet.everstake.one." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="everstake", chain="neon"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="everstake", chain="neon"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="everstake", chain="neon"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="everstake", chain="neon"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="everstake", chain="neon"}) / sum(ocb:rpc_call:rate_24h{provider="everstake", chain="neon"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="everstake", chain="neon"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="everstake", chain="neon"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="everstake", chain="neon", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="everstake", chain="neon", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="everstake", chain="neon", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="everstake", chain="neon", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="everstake", chain="neon", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="everstake", chain="neon", region="sgp"}[1h]) diff --git a/benchmarks/oktc-rpc.yml b/benchmarks/oktc-rpc.yml new file mode 100644 index 00000000..66781bd3 --- /dev/null +++ b/benchmarks/oktc-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 231 + +slug: oktc-rpc +number: "231" +title: Fastest free OKTC RPC, live no-key endpoint latency +seo_title: "Fastest free OKTC RPC 2026" +seo_description: "{{best_name}} leads free OKTC RPC at {{best_p50}} (eth_getBlockByNumber EVM p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for eth_getBlockByNumber against every available public OKTC node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + OKTC (OKX Token Chain, formerly OKChain) is an EVM-compatible Layer 1 blockchain (chain ID 66) developed by OKX, targeting high throughput and low fees for DeFi applications. It exposes a standard Ethereum JSON-RPC interface. Public EVM endpoints are available without an API key from OKX Chain Official, Thirdweb and dRPC. Every provider was live-verified with consecutive eth_getBlockByNumber probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to OKTC. + We measure the round-trip latency of a single eth_getBlockByNumber + ("latest", false) call against every available public OKTC node + that sustains continuous probing: 3 providers at launch, every 60 + seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + a standard EVM staleness gap. The cross-chain view lives on the + parent rpc-capabilities benchmark; this page is the OKTC-scoped + answer with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: {\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"eth_getBlockByNumber\",\"params\":[\"latest\",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable block number), http_err, jsonrpc_err, stale, timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=oktc. Provider coverage at launch: 3 endpoints (OKX Chain Official, Thirdweb, dRPC)." + +findings: + - "{{best_name}} currently leads OKTC RPC at {{best_p50}} (eth_getBlockByNumber p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free OKTC RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (OKTC block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which OKTC RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: OKX Chain Official (exchainrpc.okex.org), Thirdweb (66.rpc.thirdweb.com) and dRPC (oktc.drpc.org). Every listed endpoint was live-verified with an eth_getBlockByNumber call returning a parsable block number before inclusion." + - q: "Does the fastest OKTC RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is OKTC RPC latency measured here, technically?" + a: "One eth_getBlockByNumber JSON-RPC call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="oktc"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: oktc-official + name: OKX Chain Official + tag: OKX Chain official public RPC (exchainrpc.okex.org), keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to exchainrpc.okex.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="oktc-official", chain="oktc"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="oktc-official", chain="oktc"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="oktc-official", chain="oktc"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="oktc-official", chain="oktc"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="oktc-official", chain="oktc"}) / sum(ocb:rpc_call:rate_24h{provider="oktc-official", chain="oktc"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="oktc-official", chain="oktc"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="oktc-official", chain="oktc"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="oktc-official", chain="oktc", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="oktc-official", chain="oktc", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="oktc-official", chain="oktc", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="oktc-official", chain="oktc", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="oktc-official", chain="oktc", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="oktc-official", chain="oktc", region="sgp"}[1h]) + + - slug: thirdweb + name: Thirdweb + tag: Thirdweb public OKTC RPC (chain 66), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to 66.rpc.thirdweb.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="oktc"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thirdweb", chain="oktc"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thirdweb", chain="oktc"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thirdweb", chain="oktc"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thirdweb", chain="oktc"}) / sum(ocb:rpc_call:rate_24h{provider="thirdweb", chain="oktc"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thirdweb", chain="oktc"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="oktc"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="oktc", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="oktc", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="oktc", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="oktc", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="oktc", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="oktc", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: dRPC decentralised multi-chain RPC, public OKTC endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to oktc.drpc.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="oktc"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="oktc"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="oktc"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="oktc"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="oktc"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="oktc"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="oktc"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="oktc"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="oktc", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="oktc", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="oktc", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="oktc", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="oktc", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="oktc", region="sgp"}[1h]) diff --git a/benchmarks/tezos-rpc.yml b/benchmarks/tezos-rpc.yml new file mode 100644 index 00000000..2cb38bf1 --- /dev/null +++ b/benchmarks/tezos-rpc.yml @@ -0,0 +1,135 @@ +# OpenChainBench. Bench No 222 + +slug: tezos-rpc +number: "222" +title: Fastest free Tezos RPC, live no-key endpoint latency +seo_title: "Fastest free Tezos RPC 2026" +seo_description: "{{best_name}} leads free Tezos RPC at {{best_p50}} (block level REST p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for GET /chains/main/blocks/head/header against every available public Tezos node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Tezos is a self-amending proof-of-stake blockchain using Liquid Proof of Stake (LPoS) and an on-chain governance mechanism that allows protocol upgrades without hard forks. It targets roughly one block every 30 seconds on mainnet. Public REST endpoints are available without an API key from ECADinfra, TezBeta and TzKT (Baking Bad). Every provider was live-verified with consecutive block header probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Tezos. + We measure the round-trip latency of a single REST call (GET + /chains/main/blocks/head/header) against every available public + Tezos node that sustains continuous probing: 3 providers at launch, + every 60 seconds, from us-east, eu-west and Singapore. The harness + classifies every response (ok / http_err / jsonrpc_err / stale / + timeout) with a Tezos-scaled staleness gap (10 blocks, around + 5 min at 30 s/block). The cross-chain view lives on the parent + rpc-capabilities benchmark; this page is the Tezos-scoped answer + with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: HTTP GET /chains/main/blocks/head/header. Plain REST call. The response carries a JSON object with the level field as a plain integer." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable level integer), http_err, jsonrpc_err, stale (block more than 10 behind the cross-provider tip), timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=tezos. Provider coverage at launch: 3 endpoints (ECADinfra, TezBeta, TzKT)." + +findings: + - "{{best_name}} currently leads Tezos RPC at {{best_p50}} (block level REST p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Tezos RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Tezos block level p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Tezos RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: ECADinfra (mainnet.ecadinfra.com), TezBeta (rpc.tzbeta.net) and TzKT by Baking Bad (rpc.tzkt.io/mainnet). Every listed endpoint was live-verified with a block header call returning a parsable level before inclusion." + - q: "Does the fastest Tezos RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is Tezos RPC latency measured here, technically?" + a: "One GET /chains/main/blocks/head/header REST call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="tezos"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: ecadinfra + name: ECADinfra + tag: ECADinfra public Tezos mainnet RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /chains/main/blocks/head/header sent every 60s from 3 regions to mainnet.ecadinfra.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ecadinfra", chain="tezos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ecadinfra", chain="tezos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ecadinfra", chain="tezos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ecadinfra", chain="tezos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ecadinfra", chain="tezos"}) / sum(ocb:rpc_call:rate_24h{provider="ecadinfra", chain="tezos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ecadinfra", chain="tezos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ecadinfra", chain="tezos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ecadinfra", chain="tezos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ecadinfra", chain="tezos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ecadinfra", chain="tezos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ecadinfra", chain="tezos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ecadinfra", chain="tezos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ecadinfra", chain="tezos", region="sgp"}[1h]) + + - slug: tzbeta + name: TezBeta + tag: TezBeta public Tezos mainnet RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /chains/main/blocks/head/header sent every 60s from 3 regions to rpc.tzbeta.net." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzbeta", chain="tezos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="tzbeta", chain="tezos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="tzbeta", chain="tezos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="tzbeta", chain="tezos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="tzbeta", chain="tezos"}) / sum(ocb:rpc_call:rate_24h{provider="tzbeta", chain="tezos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="tzbeta", chain="tezos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="tzbeta", chain="tezos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzbeta", chain="tezos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tzbeta", chain="tezos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzbeta", chain="tezos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tzbeta", chain="tezos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzbeta", chain="tezos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tzbeta", chain="tezos", region="sgp"}[1h]) + + - slug: tzkt + name: TzKT (Baking Bad) + tag: TzKT public Tezos mainnet RPC by Baking Bad, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /chains/main/blocks/head/header sent every 60s from 3 regions to rpc.tzkt.io/mainnet." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzkt", chain="tezos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="tzkt", chain="tezos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="tzkt", chain="tezos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="tzkt", chain="tezos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="tzkt", chain="tezos"}) / sum(ocb:rpc_call:rate_24h{provider="tzkt", chain="tezos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="tzkt", chain="tezos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="tzkt", chain="tezos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzkt", chain="tezos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tzkt", chain="tezos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzkt", chain="tezos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tzkt", chain="tezos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tzkt", chain="tezos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tzkt", chain="tezos", region="sgp"}[1h]) diff --git a/benchmarks/thundercore-rpc.yml b/benchmarks/thundercore-rpc.yml new file mode 100644 index 00000000..1e5242a4 --- /dev/null +++ b/benchmarks/thundercore-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 230 + +slug: thundercore-rpc +number: "230" +title: Fastest free ThunderCore RPC, live no-key endpoint latency +seo_title: "Fastest free ThunderCore RPC 2026" +seo_description: "{{best_name}} leads free ThunderCore RPC at {{best_p50}} (eth_getBlockByNumber EVM p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for eth_getBlockByNumber against every available public ThunderCore node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + ThunderCore is an EVM-compatible Layer 1 blockchain (chain ID 108) designed for high throughput, producing approximately one block per second with fast finality. It runs a modified version of Ethereum with the Thunder consensus protocol and exposes a standard JSON-RPC interface. Public EVM endpoints are available without an API key from ThunderCore Official, Thirdweb and dRPC. Every provider was live-verified with consecutive eth_getBlockByNumber probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to ThunderCore. + We measure the round-trip latency of a single eth_getBlockByNumber + ("latest", false) call against every available public ThunderCore + node that sustains continuous probing: 3 providers at launch, every + 60 seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + a standard EVM staleness gap. The cross-chain view lives on the + parent rpc-capabilities benchmark; this page is the ThunderCore-scoped + answer with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: {\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"eth_getBlockByNumber\",\"params\":[\"latest\",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable block number), http_err, jsonrpc_err, stale, timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=thundercore. Provider coverage at launch: 3 endpoints (ThunderCore Official, Thirdweb, dRPC)." + +findings: + - "{{best_name}} currently leads ThunderCore RPC at {{best_p50}} (eth_getBlockByNumber p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free ThunderCore RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (ThunderCore block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which ThunderCore RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: ThunderCore Official (mainnet-rpc.thundercore.com), Thirdweb (108.rpc.thirdweb.com) and dRPC (thundercore.drpc.org). Every listed endpoint was live-verified with an eth_getBlockByNumber call returning a parsable block number before inclusion." + - q: "Does the fastest ThunderCore RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is ThunderCore RPC latency measured here, technically?" + a: "One eth_getBlockByNumber JSON-RPC call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="thundercore"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: thundercore-official + name: ThunderCore Official + tag: ThunderCore official public RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to mainnet-rpc.thundercore.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thundercore-official", chain="thundercore"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thundercore-official", chain="thundercore"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thundercore-official", chain="thundercore"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thundercore-official", chain="thundercore"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thundercore-official", chain="thundercore"}) / sum(ocb:rpc_call:rate_24h{provider="thundercore-official", chain="thundercore"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thundercore-official", chain="thundercore"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thundercore-official", chain="thundercore"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thundercore-official", chain="thundercore", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thundercore-official", chain="thundercore", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thundercore-official", chain="thundercore", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thundercore-official", chain="thundercore", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thundercore-official", chain="thundercore", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thundercore-official", chain="thundercore", region="sgp"}[1h]) + + - slug: thirdweb + name: Thirdweb + tag: Thirdweb public ThunderCore RPC (chain 108), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to 108.rpc.thirdweb.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="thundercore"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thirdweb", chain="thundercore"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thirdweb", chain="thundercore"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thirdweb", chain="thundercore"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thirdweb", chain="thundercore"}) / sum(ocb:rpc_call:rate_24h{provider="thirdweb", chain="thundercore"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thirdweb", chain="thundercore"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="thundercore"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="thundercore", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="thundercore", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="thundercore", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="thundercore", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="thundercore", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="thundercore", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: dRPC decentralised multi-chain RPC, public ThunderCore endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to thundercore.drpc.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="thundercore"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="thundercore"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="thundercore"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="thundercore"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="thundercore"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="thundercore"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="thundercore"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="thundercore"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="thundercore", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="thundercore", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="thundercore", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="thundercore", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="thundercore", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="thundercore", region="sgp"}[1h]) diff --git a/benchmarks/vechain-rpc.yml b/benchmarks/vechain-rpc.yml new file mode 100644 index 00000000..7a9197a2 --- /dev/null +++ b/benchmarks/vechain-rpc.yml @@ -0,0 +1,135 @@ +# OpenChainBench. Bench No 224 + +slug: vechain-rpc +number: "224" +title: Fastest free VeChain RPC, live no-key endpoint latency +seo_title: "Fastest free VeChain RPC 2026" +seo_description: "{{best_name}} leads free VeChain RPC at {{best_p50}} (blocks/best number p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for GET /blocks/best against every available public VeChain node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + VeChain is a proof-of-authority enterprise blockchain targeting supply chain transparency and IoT use cases, producing one block every 10 seconds. It uses a two-token model (VET + VTHO) and exposes a REST API at /blocks/best for the latest committed block. Public REST endpoints are available without an API key from the VeChain Foundation (mainnet.vechain.org, vethor-node.vechain.com) and VeChain.energy. Every provider was live-verified with consecutive block probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to VeChain. + We measure the round-trip latency of a single REST call (GET + /blocks/best) against every available public VeChain node that + sustains continuous probing: 3 providers at launch, every 60 + seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + a VeChain-scaled staleness gap (30 blocks, around 5 min at + 10 s/block). The cross-chain view lives on the parent + rpc-capabilities benchmark; this page is the VeChain-scoped answer + with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: HTTP GET /blocks/best. Plain REST call. The response carries number as a plain unsigned integer." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable number integer), http_err, jsonrpc_err, stale (block more than 30 behind the cross-provider tip), timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=vechain. Provider coverage at launch: 3 endpoints (VeChain Foundation x2, VeChain.energy)." + +findings: + - "{{best_name}} currently leads VeChain RPC at {{best_p50}} (blocks/best number p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free VeChain RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (VeChain block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which VeChain RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: VeChain Foundation mainnet node (mainnet.vechain.org), VeThor Node (vethor-node.vechain.com) and VeChain.energy community node (node-mainnet.vechain.energy). Every listed endpoint was live-verified with a blocks/best call returning a parsable block number before inclusion." + - q: "Does the fastest VeChain RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is VeChain RPC latency measured here, technically?" + a: "One GET /blocks/best REST call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="vechain"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: vechain-foundation + name: VeChain Foundation + tag: VeChain Foundation official mainnet node, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /blocks/best sent every 60s from 3 regions to mainnet.vechain.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-foundation", chain="vechain"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="vechain-foundation", chain="vechain"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="vechain-foundation", chain="vechain"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="vechain-foundation", chain="vechain"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="vechain-foundation", chain="vechain"}) / sum(ocb:rpc_call:rate_24h{provider="vechain-foundation", chain="vechain"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="vechain-foundation", chain="vechain"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="vechain-foundation", chain="vechain"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-foundation", chain="vechain", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vechain-foundation", chain="vechain", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-foundation", chain="vechain", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vechain-foundation", chain="vechain", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-foundation", chain="vechain", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vechain-foundation", chain="vechain", region="sgp"}[1h]) + + - slug: vethor-node + name: VeThor Node + tag: VeChain Foundation VeThor public node, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /blocks/best sent every 60s from 3 regions to vethor-node.vechain.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vethor-node", chain="vechain"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="vethor-node", chain="vechain"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="vethor-node", chain="vechain"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="vethor-node", chain="vechain"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="vethor-node", chain="vechain"}) / sum(ocb:rpc_call:rate_24h{provider="vethor-node", chain="vechain"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="vethor-node", chain="vechain"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="vethor-node", chain="vechain"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vethor-node", chain="vechain", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vethor-node", chain="vechain", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vethor-node", chain="vechain", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vethor-node", chain="vechain", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vethor-node", chain="vechain", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vethor-node", chain="vechain", region="sgp"}[1h]) + + - slug: vechain-energy + name: VeChain.energy + tag: VeChain.energy community node, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /blocks/best sent every 60s from 3 regions to node-mainnet.vechain.energy." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-energy", chain="vechain"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="vechain-energy", chain="vechain"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="vechain-energy", chain="vechain"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="vechain-energy", chain="vechain"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="vechain-energy", chain="vechain"}) / sum(ocb:rpc_call:rate_24h{provider="vechain-energy", chain="vechain"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="vechain-energy", chain="vechain"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="vechain-energy", chain="vechain"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-energy", chain="vechain", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vechain-energy", chain="vechain", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-energy", chain="vechain", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vechain-energy", chain="vechain", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="vechain-energy", chain="vechain", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="vechain-energy", chain="vechain", region="sgp"}[1h]) diff --git a/benchmarks/viction-rpc.yml b/benchmarks/viction-rpc.yml new file mode 100644 index 00000000..2e8303dc --- /dev/null +++ b/benchmarks/viction-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 229 + +slug: viction-rpc +number: "229" +title: Fastest free Viction RPC, live no-key endpoint latency +seo_title: "Fastest free Viction RPC 2026" +seo_description: "{{best_name}} leads free Viction RPC at {{best_p50}} (eth_getBlockByNumber EVM p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for eth_getBlockByNumber against every available public Viction node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Viction (formerly TomoChain) is a proof-of-stake-voting EVM L1 blockchain (chain ID 88) with 2-second block times, targeting low fees and high throughput for DeFi and NFTs. It exposes a standard Ethereum JSON-RPC interface. Public EVM endpoints are available without an API key from Viction Official, Thirdweb and dRPC. Every provider was live-verified with consecutive eth_getBlockByNumber probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Viction. + We measure the round-trip latency of a single eth_getBlockByNumber + ("latest", false) call against every available public Viction node + that sustains continuous probing: 3 providers at launch, every 60 + seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + a standard EVM staleness gap. The cross-chain view lives on the + parent rpc-capabilities benchmark; this page is the Viction-scoped + answer with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: {\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"eth_getBlockByNumber\",\"params\":[\"latest\",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable block number), http_err, jsonrpc_err, stale, timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=viction. Provider coverage at launch: 3 endpoints (Viction Official, Thirdweb, dRPC)." + +findings: + - "{{best_name}} currently leads Viction RPC at {{best_p50}} (eth_getBlockByNumber p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Viction RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Viction block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Viction RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Viction Official (rpc.viction.xyz), Thirdweb (88.rpc.thirdweb.com) and dRPC (viction.drpc.org). Every listed endpoint was live-verified with an eth_getBlockByNumber call returning a parsable block number before inclusion." + - q: "Does the fastest Viction RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is Viction RPC latency measured here, technically?" + a: "One eth_getBlockByNumber JSON-RPC call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="viction"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: viction-official + name: Viction Official + tag: Viction official public RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to rpc.viction.xyz." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="viction-official", chain="viction"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="viction-official", chain="viction"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="viction-official", chain="viction"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="viction-official", chain="viction"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="viction-official", chain="viction"}) / sum(ocb:rpc_call:rate_24h{provider="viction-official", chain="viction"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="viction-official", chain="viction"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="viction-official", chain="viction"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="viction-official", chain="viction", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="viction-official", chain="viction", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="viction-official", chain="viction", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="viction-official", chain="viction", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="viction-official", chain="viction", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="viction-official", chain="viction", region="sgp"}[1h]) + + - slug: thirdweb + name: Thirdweb + tag: Thirdweb public Viction RPC (chain 88), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to 88.rpc.thirdweb.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="viction"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thirdweb", chain="viction"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thirdweb", chain="viction"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thirdweb", chain="viction"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thirdweb", chain="viction"}) / sum(ocb:rpc_call:rate_24h{provider="thirdweb", chain="viction"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thirdweb", chain="viction"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="viction"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="viction", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="viction", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="viction", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="viction", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="viction", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="viction", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: dRPC decentralised multi-chain RPC, public Viction endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for an eth_getBlockByNumber POST sent every 60s from 3 regions to viction.drpc.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="viction"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="viction"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="viction"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="viction"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="viction"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="viction"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="viction"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="viction"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="viction", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="viction", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="viction", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="viction", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="viction", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="viction", region="sgp"}[1h]) diff --git a/benchmarks/waves-rpc.yml b/benchmarks/waves-rpc.yml new file mode 100644 index 00000000..27098a3c --- /dev/null +++ b/benchmarks/waves-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 225 + +slug: waves-rpc +number: "225" +title: Fastest free Waves RPC, live no-key endpoint latency +seo_title: "Fastest free Waves RPC 2026" +seo_description: "{{best_name}} leads free Waves RPC at {{best_p50}} (blocks/last height p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for GET /blocks/last against every available public Waves node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Waves is a proof-of-stake blockchain optimised for decentralised finance and token creation, producing one block approximately every 60 seconds. The chain exposes a REST API at /blocks/last returning the latest committed block height as a plain integer. Public REST endpoints are available without an API key from the Waves Foundation, Waves.Exchange and nodes.waves.exchange. Every provider was live-verified with consecutive block probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Waves. + We measure the round-trip latency of a single REST call (GET + /blocks/last) against every available public Waves node that sustains + continuous probing: 3 providers at launch, every 60 seconds, from + us-east, eu-west and Singapore. The harness classifies every response + (ok / http_err / jsonrpc_err / stale / timeout) with a Waves-scaled + staleness gap (5 blocks, around 5 min at 60 s/block). The cross-chain + view lives on the parent rpc-capabilities benchmark; this page is the + Waves-scoped answer with per-region breakdowns as a first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: HTTP GET /blocks/last. Plain REST call. The response carries height as a plain integer." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable height integer), http_err, jsonrpc_err, stale (block more than 5 behind the cross-provider tip), timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=waves. Provider coverage at launch: 3 endpoints (Waves Foundation, Waves.Exchange x2)." + +findings: + - "{{best_name}} currently leads Waves RPC at {{best_p50}} (blocks/last height p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Waves RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Waves block height p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Waves RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Waves Foundation nodes (nodes.wavesnodes.com), Waves.Exchange (nodes.wx.network) and WavesExchange (nodes.waves.exchange). Every listed endpoint was live-verified with a blocks/last call returning a parsable height before inclusion." + - q: "Does the fastest Waves RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is Waves RPC latency measured here, technically?" + a: "One GET /blocks/last REST call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="waves"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: wavesnodes + name: Waves Foundation + tag: Waves Foundation official public nodes, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /blocks/last sent every 60s from 3 regions to nodes.wavesnodes.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wavesnodes", chain="waves"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="wavesnodes", chain="waves"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="wavesnodes", chain="waves"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="wavesnodes", chain="waves"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="wavesnodes", chain="waves"}) / sum(ocb:rpc_call:rate_24h{provider="wavesnodes", chain="waves"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="wavesnodes", chain="waves"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="wavesnodes", chain="waves"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wavesnodes", chain="waves", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="wavesnodes", chain="waves", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wavesnodes", chain="waves", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="wavesnodes", chain="waves", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wavesnodes", chain="waves", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="wavesnodes", chain="waves", region="sgp"}[1h]) + + - slug: wx-network + name: Waves.Exchange + tag: Waves.Exchange public node (nodes.wx.network), keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /blocks/last sent every 60s from 3 regions to nodes.wx.network." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wx-network", chain="waves"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="wx-network", chain="waves"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="wx-network", chain="waves"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="wx-network", chain="waves"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="wx-network", chain="waves"}) / sum(ocb:rpc_call:rate_24h{provider="wx-network", chain="waves"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="wx-network", chain="waves"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="wx-network", chain="waves"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wx-network", chain="waves", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="wx-network", chain="waves", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wx-network", chain="waves", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="wx-network", chain="waves", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="wx-network", chain="waves", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="wx-network", chain="waves", region="sgp"}[1h]) + + - slug: waves-exchange + name: WavesExchange + tag: WavesExchange public node (nodes.waves.exchange), keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /blocks/last sent every 60s from 3 regions to nodes.waves.exchange." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waves-exchange", chain="waves"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="waves-exchange", chain="waves"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="waves-exchange", chain="waves"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="waves-exchange", chain="waves"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="waves-exchange", chain="waves"}) / sum(ocb:rpc_call:rate_24h{provider="waves-exchange", chain="waves"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="waves-exchange", chain="waves"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="waves-exchange", chain="waves"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waves-exchange", chain="waves", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="waves-exchange", chain="waves", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waves-exchange", chain="waves", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="waves-exchange", chain="waves", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waves-exchange", chain="waves", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="waves-exchange", chain="waves", region="sgp"}[1h]) diff --git a/benchmarks/wax-rpc.yml b/benchmarks/wax-rpc.yml new file mode 100644 index 00000000..b4980a7b --- /dev/null +++ b/benchmarks/wax-rpc.yml @@ -0,0 +1,135 @@ +# OpenChainBench. Bench No 226 + +slug: wax-rpc +number: "226" +title: Fastest free WAX RPC, live no-key endpoint latency +seo_title: "Fastest free WAX RPC 2026" +seo_description: "{{best_name}} leads free WAX RPC at {{best_p50}} (get_info head_block_num p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for GET /v1/chain/get_info against every available public WAX (Antelope) node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + WAX (Worldwide Asset eXchange) is a delegated proof-of-stake blockchain built on the Antelope protocol, specialising in NFTs and gaming assets. It produces one block every 0.5 seconds and operates the same /v1/chain/get_info REST endpoint as EOS. Public endpoints are available without an API key from Greymass, EOSUSA and WAX Sweden. Every provider was live-verified with consecutive get_info probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to WAX. + We measure the round-trip latency of a single REST call (GET + /v1/chain/get_info) against every available public WAX node that + sustains continuous probing: 3 providers at launch, every 60 + seconds, from us-east, eu-west and Singapore. The harness classifies + every response (ok / http_err / jsonrpc_err / stale / timeout) with + a WAX-scaled staleness gap (600 blocks, around 5 min at 0.5 s/block). + The cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the WAX-scoped answer with per-region breakdowns as a + first-class dimension. + +methodology: + - "Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs." + - "Payload: HTTP GET /v1/chain/get_info. Plain REST call. The response carries head_block_num as a plain integer." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus quantile_over_time over the last 24 hours." + - "Call-result classification: ok (HTTP 200 + parsable head_block_num integer), http_err, jsonrpc_err, stale (block more than 600 behind the cross-provider tip), timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=wax. Provider coverage at launch: 3 endpoints (Greymass, EOSUSA, WAX Sweden)." + +findings: + - "{{best_name}} currently leads WAX RPC at {{best_p50}} (get_info head_block_num p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free WAX RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (WAX head block number p50 over the last 24h), measured against 3 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which WAX RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Greymass (wax.greymass.com), EOSUSA (wax.eosusa.io) and WAX Sweden (api.waxsweden.org). Every listed endpoint was live-verified with a get_info call returning a parsable head_block_num before inclusion." + - q: "Does the fastest WAX RPC change by region?" + a: "Often. Public infra concentrates in specific regions; a gateway that wins from Amsterdam can lose from Singapore by multiples. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is WAX RPC latency measured here, technically?" + a: "One GET /v1/chain/get_info REST call every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 are computed via Prometheus quantile_over_time over 24 hours. Best-effort measurements; p50 is the median, p90 the 90th percentile and p99 the 99th percentile of latency samples collected over the last 24 hours." + +source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities + +prometheus: + window: 24h + freshness_metric: rpc_latency_milliseconds + +rank_matrix_query: avg by (provider, region) (ocb:rpc_latency_milliseconds:p50_24h{chain="wax"}) + +dimensions: + region: + - { value: all, label: All regions } + - { value: us-east, label: US-East } + - { value: eu-west, label: EU-West } + - { value: sgp, label: Singapore } + +providers: + - slug: greymass + name: Greymass + tag: Greymass public WAX Antelope API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/chain/get_info sent every 60s from 3 regions to wax.greymass.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="wax"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="greymass", chain="wax"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="greymass", chain="wax"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="greymass", chain="wax"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="greymass", chain="wax"}) / sum(ocb:rpc_call:rate_24h{provider="greymass", chain="wax"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="greymass", chain="wax"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="wax"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="wax", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="wax", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="wax", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="wax", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="greymass", chain="wax", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="greymass", chain="wax", region="sgp"}[1h]) + + - slug: eosusa + name: EOSUSA + tag: EOSUSA public WAX Antelope API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/chain/get_info sent every 60s from 3 regions to wax.eosusa.io." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosusa", chain="wax"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="eosusa", chain="wax"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="eosusa", chain="wax"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="eosusa", chain="wax"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="eosusa", chain="wax"}) / sum(ocb:rpc_call:rate_24h{provider="eosusa", chain="wax"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="eosusa", chain="wax"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="eosusa", chain="wax"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosusa", chain="wax", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="eosusa", chain="wax", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosusa", chain="wax", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="eosusa", chain="wax", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="eosusa", chain="wax", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="eosusa", chain="wax", region="sgp"}[1h]) + + - slug: waxsweden + name: WAX Sweden + tag: WAX Sweden public Antelope API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/chain/get_info sent every 60s from 3 regions to api.waxsweden.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waxsweden", chain="wax"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="waxsweden", chain="wax"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="waxsweden", chain="wax"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="waxsweden", chain="wax"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="waxsweden", chain="wax"}) / sum(ocb:rpc_call:rate_24h{provider="waxsweden", chain="wax"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="waxsweden", chain="wax"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="waxsweden", chain="wax"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waxsweden", chain="wax", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="waxsweden", chain="wax", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waxsweden", chain="wax", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="waxsweden", chain="wax", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="waxsweden", chain="wax", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="waxsweden", chain="wax", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index e45551a9..0eeaa976 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -1616,6 +1616,111 @@ func chains() []Chain { {Slug: "ngd2", Name: "NGD (2)", URL: envDefault("RPC_URL_NEO_NGD2", "https://n3seed2.ngd.network:10332")}, }, }, + // 2026-08-18 wave-8. Tezos L1 — REST GET /chains/main/blocks/head/header, ~30 s/block. 3 keyless providers. + { + Slug: "tezos", + Name: "Tezos", + Kind: "tezos", + Providers: []Provider{ + {Slug: "ecadinfra", Name: "ECADinfra", URL: envDefault("RPC_URL_TEZOS_ECADINFRA", "https://mainnet.ecadinfra.com")}, + {Slug: "tzbeta", Name: "TezBeta", URL: envDefault("RPC_URL_TEZOS_TZBETA", "https://rpc.tzbeta.net")}, + {Slug: "tzkt", Name: "TzKT (Baking Bad)", URL: envDefault("RPC_URL_TEZOS_TZKT", "https://rpc.tzkt.io/mainnet")}, + }, + }, + // 2026-08-18 wave-8. EOS (Antelope) L1 — REST GET /v1/chain/get_info, ~0.5 s/block. 3 keyless providers. + { + Slug: "eos", + Name: "EOS", + Kind: "antelope", + Providers: []Provider{ + {Slug: "greymass", Name: "Greymass", URL: envDefault("RPC_URL_EOS_GREYMASS", "https://eos.greymass.com")}, + {Slug: "eosnation", Name: "EOS Nation", URL: envDefault("RPC_URL_EOS_EOSNATION", "https://eos.api.eosnation.io")}, + {Slug: "alohaeos", Name: "Aloha EOS", URL: envDefault("RPC_URL_EOS_ALOHAEOS", "https://api.main.alohaeos.com")}, + }, + }, + // 2026-08-18 wave-8. VeChain L1 — REST GET /blocks/best, ~10 s/block. 3 keyless providers. + { + Slug: "vechain", + Name: "VeChain", + Kind: "vechain", + Providers: []Provider{ + {Slug: "vechain-foundation", Name: "VeChain Foundation", URL: envDefault("RPC_URL_VECHAIN_FOUNDATION", "https://mainnet.vechain.org")}, + {Slug: "vethor-node", Name: "VeThor Node", URL: envDefault("RPC_URL_VECHAIN_VETHOR", "https://vethor-node.vechain.com")}, + {Slug: "vechain-energy", Name: "VeChain.energy", URL: envDefault("RPC_URL_VECHAIN_ENERGY", "https://node-mainnet.vechain.energy")}, + }, + }, + // 2026-08-18 wave-8. Waves L1 — REST GET /blocks/last, ~60 s/block. 3 keyless providers. + { + Slug: "waves", + Name: "Waves", + Kind: "waves", + Providers: []Provider{ + {Slug: "wavesnodes", Name: "Waves Foundation", URL: envDefault("RPC_URL_WAVES_WAVESNODES", "https://nodes.wavesnodes.com")}, + {Slug: "wx-network", Name: "Waves.Exchange", URL: envDefault("RPC_URL_WAVES_WX", "https://nodes.wx.network")}, + {Slug: "waves-exchange", Name: "WavesExchange", URL: envDefault("RPC_URL_WAVES_EXCHANGE", "https://nodes.waves.exchange")}, + }, + }, + // 2026-08-18 wave-8. WAX gaming blockchain (Antelope) — REST GET /v1/chain/get_info, ~0.5 s/block. 3 keyless providers. + { + Slug: "wax", + Name: "WAX", + Kind: "antelope", + Providers: []Provider{ + {Slug: "greymass", Name: "Greymass", URL: envDefault("RPC_URL_WAX_GREYMASS", "https://wax.greymass.com")}, + {Slug: "eosusa", Name: "EOSUSA", URL: envDefault("RPC_URL_WAX_EOSUSA", "https://wax.eosusa.io")}, + {Slug: "waxsweden", Name: "WAX Sweden", URL: envDefault("RPC_URL_WAX_SWEDEN", "https://api.waxsweden.org")}, + }, + }, + // 2026-08-18 wave-8. Neon EVM — EVM runtime on Solana (chain 245022934), eth_getBlockByNumber probe. 3 keyless providers. + { + Slug: "neon", + Name: "Neon EVM", + Providers: []Provider{ + {Slug: "neon-p2p", Name: "P2P Neon Proxy", URL: envDefault("RPC_URL_NEON_P2P", "https://neon-proxy-mainnet.solana.p2p.org")}, + {Slug: "thirdweb", Name: "Thirdweb", URL: envDefault("RPC_URL_NEON_THIRDWEB", "https://245022934.rpc.thirdweb.com")}, + {Slug: "everstake", Name: "Everstake", URL: envDefault("RPC_URL_NEON_EVERSTAKE", "https://neon-mainnet.everstake.one")}, + }, + }, + // 2026-08-18 wave-8. Merlin Chain — Bitcoin L2 EVM (chain 4200), eth_getBlockByNumber probe. 3 keyless providers. + { + Slug: "merlin", + Name: "Merlin Chain", + Providers: []Provider{ + {Slug: "merlin-official", Name: "Merlin Official", URL: envDefault("RPC_URL_MERLIN_OFFICIAL", "https://rpc.merlinchain.io")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_MERLIN_DRPC", "https://merlin.drpc.org")}, + {Slug: "thirdweb", Name: "Thirdweb", URL: envDefault("RPC_URL_MERLIN_THIRDWEB", "https://4200.rpc.thirdweb.com")}, + }, + }, + // 2026-08-18 wave-8. Viction (TomoChain) — EVM L1 (chain 88), eth_getBlockByNumber probe. 3 keyless providers. + { + Slug: "viction", + Name: "Viction", + Providers: []Provider{ + {Slug: "viction-official", Name: "Viction Official", URL: envDefault("RPC_URL_VICTION_OFFICIAL", "https://rpc.viction.xyz")}, + {Slug: "thirdweb", Name: "Thirdweb", URL: envDefault("RPC_URL_VICTION_THIRDWEB", "https://88.rpc.thirdweb.com")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_VICTION_DRPC", "https://viction.drpc.org")}, + }, + }, + // 2026-08-18 wave-8. ThunderCore — EVM L1 (chain 108), eth_getBlockByNumber probe. 3 keyless providers. + { + Slug: "thundercore", + Name: "ThunderCore", + Providers: []Provider{ + {Slug: "thundercore-official", Name: "ThunderCore Official", URL: envDefault("RPC_URL_THUNDERCORE_OFFICIAL", "https://mainnet-rpc.thundercore.com")}, + {Slug: "thirdweb", Name: "Thirdweb", URL: envDefault("RPC_URL_THUNDERCORE_THIRDWEB", "https://108.rpc.thirdweb.com")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_THUNDERCORE_DRPC", "https://thundercore.drpc.org")}, + }, + }, + // 2026-08-18 wave-8. OKTC (OKX Token Chain) — EVM L1 (chain 66), eth_getBlockByNumber probe. 3 keyless providers. + { + Slug: "oktc", + Name: "OKTC", + Providers: []Provider{ + {Slug: "oktc-official", Name: "OKX Chain Official", URL: envDefault("RPC_URL_OKTC_OFFICIAL", "https://exchainrpc.okex.org")}, + {Slug: "thirdweb", Name: "Thirdweb", URL: envDefault("RPC_URL_OKTC_THIRDWEB", "https://66.rpc.thirdweb.com")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_OKTC_DRPC", "https://oktc.drpc.org")}, + }, + }, } filter := strings.TrimSpace(os.Getenv("OCB_CHAINS")) diff --git a/harnesses/rpc-capabilities/cmd/script/probe.go b/harnesses/rpc-capabilities/cmd/script/probe.go index b27424ac..4f402000 100644 --- a/harnesses/rpc-capabilities/cmd/script/probe.go +++ b/harnesses/rpc-capabilities/cmd/script/probe.go @@ -80,6 +80,18 @@ const ( // neoStaleBlockGap: NEO N3 commits one block every ~15 s, // so 20 blocks ≈ 5 min. neoStaleBlockGap uint64 = 20 + // tezosStaleBlockGap: Tezos commits one block every ~30 s, + // so 10 blocks ≈ 5 min. + tezosStaleBlockGap uint64 = 10 + // antelopeStaleBlockGap: Antelope (EOS/WAX) produces one block every + // ~0.5 s, so 600 blocks ≈ 5 min. + antelopeStaleBlockGap uint64 = 600 + // wavesStaleBlockGap: Waves closes a block every ~60 s, + // so 5 blocks ≈ 5 min. + wavesStaleBlockGap uint64 = 5 + // veChainStaleBlockGap: VeChain produces one block every ~10 s, + // so 30 blocks ≈ 5 min. + veChainStaleBlockGap uint64 = 30 ) // chainTips tracks the highest block seen for each chain across all @@ -268,6 +280,14 @@ func probeOne(ctx context.Context, c Chain, p Provider) { block, result, latency, err = callMultiversxNonce(probeCtx, p.URL) case "neo": block, result, latency, err = callNeoBlockCount(probeCtx, p.URL) + case "tezos": + block, result, latency, err = callTezosBlock(probeCtx, p.URL) + case "antelope": + block, result, latency, err = callAntelopeChainInfo(probeCtx, p.URL) + case "waves": + block, result, latency, err = callWavesBlock(probeCtx, p.URL) + case "vechain": + block, result, latency, err = callVeChainBlock(probeCtx, p.URL) default: block, hash, result, latency, err = callLatestBlock(probeCtx, p.URL) } @@ -309,6 +329,14 @@ func probeOne(ctx context.Context, c Chain, p Provider) { gap = multiversxStaleNonceGap case "neo": gap = neoStaleBlockGap + case "tezos": + gap = tezosStaleBlockGap + case "antelope": + gap = antelopeStaleBlockGap + case "waves": + gap = wavesStaleBlockGap + case "vechain": + gap = veChainStaleBlockGap } if tip > 0 && block+gap < tip { result = "stale" @@ -329,7 +357,8 @@ func probeOne(ctx context.Context, c Chain, p Provider) { switch c.Kind { case "solana", "polkadot", "cosmos", "starknet", "stellar", "sui", "aptos", "xrpl", "algorand", "gram", - "near", "flow", "hedera", "ckb", "multiversx", "neo": + "near", "flow", "hedera", "ckb", "multiversx", "neo", + "tezos", "antelope", "waves", "vechain": // no consensus participation default: if result == "ok" || result == "stale" { @@ -1202,6 +1231,192 @@ func callMultiversxNonce(ctx context.Context, url string) (nonce uint64, result return st.Data.Status.ErdNonce, "ok", latencyMs, nil } +// tezosBlockHeader is the shape returned by GET /chains/main/blocks/head/header +// on a Tezos node. `level` is a plain integer (not a string). +type tezosBlockHeader struct { + Level uint64 `json:"level"` +} + +// callTezosBlock probes a Tezos node via the REST endpoint +// GET /chains/main/blocks/head/header. The `level` field is the current +// block level. Staleness uses tezosStaleBlockGap in probeOne. +func callTezosBlock(ctx context.Context, url string) (level uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/chains/main/blocks/head/header" + req, _ := http.NewRequestWithContext(ctx, "GET", target, nil) + req.Header.Set("Accept", "application/json") + req.Header.Set("User-Agent", "OpenChainBench/1.0 (+https://openchainbench.com)") + client := &http.Client{Timeout: probeTimeout} + + start := time.Now() + resp, err := client.Do(req) + latencyMs = float64(time.Since(start).Nanoseconds()) / 1e6 + + if err != nil { + if ctx.Err() != nil || strings.Contains(err.Error(), "deadline exceeded") || strings.Contains(err.Error(), "Timeout") { + return 0, "timeout", latencyMs, err + } + return 0, "http_err", latencyMs, err + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + _, _ = io.Copy(io.Discard, resp.Body) + return 0, "http_err", latencyMs, fmt.Errorf("status %d", resp.StatusCode) + } + + raw, err := io.ReadAll(resp.Body) + if err != nil { + return 0, "http_err", latencyMs, err + } + var hdr tezosBlockHeader + if err := json.Unmarshal(raw, &hdr); err != nil { + return 0, "http_err", latencyMs, err + } + if hdr.Level == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("tezos block header missing level") + } + return hdr.Level, "ok", latencyMs, nil +} + +// antelopeChainInfo is the shape returned by GET /v1/chain/get_info +// on an Antelope (EOS, WAX) node. `head_block_num` is a plain integer. +type antelopeChainInfo struct { + HeadBlockNum uint64 `json:"head_block_num"` +} + +// callAntelopeChainInfo probes an Antelope (EOS/WAX) node via +// GET /v1/chain/get_info. Returns head_block_num as the block height. +// Staleness uses antelopeStaleBlockGap in probeOne. +func callAntelopeChainInfo(ctx context.Context, url string) (blockNum uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/v1/chain/get_info" + req, _ := http.NewRequestWithContext(ctx, "GET", target, nil) + req.Header.Set("Accept", "application/json") + req.Header.Set("User-Agent", "OpenChainBench/1.0 (+https://openchainbench.com)") + client := &http.Client{Timeout: probeTimeout} + + start := time.Now() + resp, err := client.Do(req) + latencyMs = float64(time.Since(start).Nanoseconds()) / 1e6 + + if err != nil { + if ctx.Err() != nil || strings.Contains(err.Error(), "deadline exceeded") || strings.Contains(err.Error(), "Timeout") { + return 0, "timeout", latencyMs, err + } + return 0, "http_err", latencyMs, err + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + _, _ = io.Copy(io.Discard, resp.Body) + return 0, "http_err", latencyMs, fmt.Errorf("status %d", resp.StatusCode) + } + + raw, err := io.ReadAll(resp.Body) + if err != nil { + return 0, "http_err", latencyMs, err + } + var info antelopeChainInfo + if err := json.Unmarshal(raw, &info); err != nil { + return 0, "http_err", latencyMs, err + } + if info.HeadBlockNum == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("antelope chain info missing head_block_num") + } + return info.HeadBlockNum, "ok", latencyMs, nil +} + +// wavesBlock is the shape returned by GET /blocks/last on a Waves node. +// `height` is a plain integer. +type wavesBlock struct { + Height uint64 `json:"height"` +} + +// callWavesBlock probes a Waves node via GET /blocks/last. +// Returns the block height. Staleness uses wavesStaleBlockGap in probeOne. +func callWavesBlock(ctx context.Context, url string) (height uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/blocks/last" + req, _ := http.NewRequestWithContext(ctx, "GET", target, nil) + req.Header.Set("Accept", "application/json") + req.Header.Set("User-Agent", "OpenChainBench/1.0 (+https://openchainbench.com)") + client := &http.Client{Timeout: probeTimeout} + + start := time.Now() + resp, err := client.Do(req) + latencyMs = float64(time.Since(start).Nanoseconds()) / 1e6 + + if err != nil { + if ctx.Err() != nil || strings.Contains(err.Error(), "deadline exceeded") || strings.Contains(err.Error(), "Timeout") { + return 0, "timeout", latencyMs, err + } + return 0, "http_err", latencyMs, err + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + _, _ = io.Copy(io.Discard, resp.Body) + return 0, "http_err", latencyMs, fmt.Errorf("status %d", resp.StatusCode) + } + + raw, err := io.ReadAll(resp.Body) + if err != nil { + return 0, "http_err", latencyMs, err + } + var blk wavesBlock + if err := json.Unmarshal(raw, &blk); err != nil { + return 0, "http_err", latencyMs, err + } + if blk.Height == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("waves block missing height") + } + return blk.Height, "ok", latencyMs, nil +} + +// veChainBlock is the shape returned by GET /blocks/best on a VeChain node. +// `number` is a plain integer (not hex). +type veChainBlock struct { + Number uint64 `json:"number"` +} + +// callVeChainBlock probes a VeChain node via GET /blocks/best. +// Returns the block number. Staleness uses veChainStaleBlockGap in probeOne. +func callVeChainBlock(ctx context.Context, url string) (blockNum uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/blocks/best" + req, _ := http.NewRequestWithContext(ctx, "GET", target, nil) + req.Header.Set("Accept", "application/json") + req.Header.Set("User-Agent", "OpenChainBench/1.0 (+https://openchainbench.com)") + client := &http.Client{Timeout: probeTimeout} + + start := time.Now() + resp, err := client.Do(req) + latencyMs = float64(time.Since(start).Nanoseconds()) / 1e6 + + if err != nil { + if ctx.Err() != nil || strings.Contains(err.Error(), "deadline exceeded") || strings.Contains(err.Error(), "Timeout") { + return 0, "timeout", latencyMs, err + } + return 0, "http_err", latencyMs, err + } + defer resp.Body.Close() + + if resp.StatusCode != 200 { + _, _ = io.Copy(io.Discard, resp.Body) + return 0, "http_err", latencyMs, fmt.Errorf("status %d", resp.StatusCode) + } + + raw, err := io.ReadAll(resp.Body) + if err != nil { + return 0, "http_err", latencyMs, err + } + var blk veChainBlock + if err := json.Unmarshal(raw, &blk); err != nil { + return 0, "http_err", latencyMs, err + } + if blk.Number == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("vechain block missing number") + } + return blk.Number, "ok", latencyMs, nil +} + // callNeoBlockCount probes a NEO N3 node via getblockcount JSON-RPC. // The result is a plain decimal integer. Staleness uses neoStaleBlockGap in probeOne. func callNeoBlockCount(ctx context.Context, url string) (count uint64, result string, latencyMs float64, err error) { diff --git a/src/data/provider-registry.ts b/src/data/provider-registry.ts index f42f255d..84c9bcda 100644 --- a/src/data/provider-registry.ts +++ b/src/data/provider-registry.ts @@ -2364,6 +2364,144 @@ export const PROVIDER_REGISTRY: Record = { twitter: "@Neo_Blockchain", parent: "ngd", }, + + // ─── Tezos providers (bench 222) ────────────────────────────── + ecadinfra: { + url: "https://ecadinfra.com", + description: + "ECADinfra operates a public Tezos mainnet node (mainnet.ecadinfra.com). Provides the Tezos RPC API without an API key.", + }, + tzbeta: { + url: "https://tzbeta.net", + description: + "TzBeta public Tezos mainnet RPC node (rpc.tzbeta.net). Free community-run Tezos RPC endpoint, no API key required.", + }, + tzkt: { + url: "https://tzkt.io", + description: + "TzKT is a Tezos blockchain explorer and API by Baking Bad. Operates a public mainnet RPC node (rpc.tzkt.io/mainnet) in addition to its indexer API.", + twitter: "@TzKT_io", + }, + + // ─── EOS providers (bench 223) ──────────────────────────────── + greymass: { + url: "https://greymass.com", + description: + "Greymass is a block producer and tooling developer for Antelope-based chains (EOS, WAX). Operates public API nodes for EOS and WAX mainnet, no API key required.", + twitter: "@greymass", + }, + eosnation: { + url: "https://eosnation.io", + description: + "EOS Nation is a block producer for EOS. Operates a public EOS mainnet API node (eos.api.eosnation.io), no API key required.", + twitter: "@EOS_Nation", + }, + alohaeos: { + url: "https://www.alohaeos.com", + description: + "Aloha EOS is a block producer for EOS. Operates a public EOS mainnet API node (api.main.alohaeos.com), no API key required.", + twitter: "@AlohaEOS", + }, + + // ─── VeChain providers (bench 224) ──────────────────────────── + "vechain-foundation": { + url: "https://vechain.org", + description: + "VeChain Foundation official public mainnet node (mainnet.vechain.org). Provides the VeChain RESTful API without an API key.", + twitter: "@vechainofficial", + }, + "vethor-node": { + url: "https://vechain.org", + description: + "VeChain Foundation public node (vethor-node.vechain.com). An additional official mainnet endpoint exposing the VeChain REST API, no API key required.", + twitter: "@vechainofficial", + parent: "vechain-foundation", + }, + "vechain-energy": { + url: "https://vechain.energy", + description: + "VeChain.energy community infrastructure for VeChain. Operates a public mainnet node (node-mainnet.vechain.energy) with the VeChain REST API, no key required.", + twitter: "@vechain_energy", + }, + + // ─── Waves providers (bench 225) ────────────────────────────── + wavesnodes: { + url: "https://wavesnodes.com", + description: + "Wavesnodes.com community-operated public Waves mainnet node (nodes.wavesnodes.com). Provides the Waves REST API without an API key.", + }, + "wx-network": { + url: "https://wx.network", + description: + "WX Network (formerly Waves Exchange) operates a public Waves mainnet node (nodes.wx.network) exposing the Waves REST API, no API key required.", + twitter: "@wxnetworkio", + }, + "waves-exchange": { + url: "https://waves.exchange", + description: + "Waves Exchange public mainnet node (nodes.wavesnodes.com). Community Waves node operated by the exchange, no API key required.", + parent: "wx-network", + }, + + // ─── WAX providers (bench 226) ──────────────────────────────── + eosusa: { + url: "https://eosusa.io", + description: + "EOSUSA is a block producer operating on multiple Antelope chains. Provides a public WAX mainnet API node (wax.eosusa.io), no API key required.", + twitter: "@eosusa_io", + }, + waxsweden: { + url: "https://waxsweden.org", + description: + "WAX Sweden is a WAX guild (block producer). Operates a public WAX mainnet API node (wax.eu.eosamsterdam.net), no API key required.", + twitter: "@waxsweden", + }, + + // ─── Neon EVM providers (bench 227) ─────────────────────────── + "neon-p2p": { + url: "https://p2p.org", + description: + "P2P.org operates a public Neon EVM mainnet proxy (neon-proxy-mainnet.solana.p2p.org). Provides a standard EVM JSON-RPC interface for Neon EVM, no API key required.", + twitter: "@p2pvalidator", + }, + everstake: { + url: "https://everstake.one", + description: + "Everstake is a staking provider that also runs public RPC infrastructure. Operates a public Neon EVM mainnet node (neon-mainnet.everstake.one), no API key required.", + twitter: "@everstake_pool", + }, + + // ─── Merlin Chain providers (bench 228) ─────────────────────── + "merlin-official": { + url: "https://merlinchain.io", + description: + "Merlin Chain official public EVM RPC node (rpc.merlinchain.io). Provides standard Ethereum JSON-RPC for the Merlin Chain Bitcoin L2, no API key required.", + twitter: "@MerlinLayer2", + }, + + // ─── Viction providers (bench 229) ──────────────────────────── + "viction-official": { + url: "https://viction.xyz", + description: + "Viction (formerly TomoChain) official public EVM RPC node (rpc.viction.xyz). Provides standard Ethereum JSON-RPC for the Viction L1, no API key required.", + twitter: "@BuildOnViction", + }, + + // ─── ThunderCore providers (bench 230) ──────────────────────── + "thundercore-official": { + url: "https://www.thundercore.com", + description: + "ThunderCore official public EVM RPC node (mainnet-rpc.thundercore.com). Provides standard Ethereum JSON-RPC for ThunderCore mainnet, no API key required.", + twitter: "@ThunderProtocol", + }, + + // ─── OKTC providers (bench 231) ─────────────────────────────── + "oktc-official": { + url: "https://www.okx.com/oktc", + description: + "OKX Chain (OKTC) official public EVM RPC node (exchainrpc.okex.org). Provides standard Ethereum JSON-RPC for OKX Token Chain mainnet, no API key required.", + twitter: "@OKXOfficial", + }, }; /** diff --git a/src/lib/brand.ts b/src/lib/brand.ts index c6bd867e..568b009f 100644 --- a/src/lib/brand.ts +++ b/src/lib/brand.ts @@ -129,6 +129,40 @@ const BRANDS: Record = { "flow-access": { color: "#00EF8B" }, // flow access inherits flow green "near-org": { color: "#00C27E" }, // near foundation inherits near green + // ─── New RPC chains (benches 222-231) ─── + tezos: { color: "#2C7DF7" }, // tezos blue (official brand kit) + eos: { color: "#453F61" }, // eos dark purple + vechain: { color: "#2C4CD8" }, // vechain blue + waves: { color: "#0055FF" }, // waves blue + wax: { color: "#F89422" }, // wax amber-orange + neon: { color: "#9333EA" }, // neon evm purple + merlin: { color: "#F7A400" }, // merlin amber (bitcoin l2 vibe) + viction: { color: "#1D61DE" }, // viction blue (ex-tomochain) + thundercore: { color: "#002868", dark: true }, // thundercore dark blue + oktc: { color: "#101010", dark: true }, // okx/oktc dark + + // ─── New providers (benches 222-231) ─── + ecadinfra: { color: "#2C7DF7" }, // tezos blue + tzbeta: { color: "#2C7DF7" }, // tezos blue + tzkt: { color: "#2C7DF7" }, // tezos blue + greymass: { color: "#453F61" }, // eos purple + eosnation: { color: "#453F61" }, // eos purple + alohaeos: { color: "#453F61" }, // eos purple + "vechain-foundation": { color: "#2C4CD8" }, // vechain blue + "vethor-node": { color: "#2C4CD8" }, // vechain blue + "vechain-energy": { color: "#2C4CD8" }, // vechain blue + wavesnodes: { color: "#0055FF" }, // waves blue + "wx-network": { color: "#0055FF" }, // waves blue + "waves-exchange": { color: "#0055FF" }, // waves blue + eosusa: { color: "#F89422" }, // wax orange + waxsweden: { color: "#F89422" }, // wax orange + "neon-p2p": { color: "#9333EA" }, // neon purple + everstake: { color: "#00D4AA" }, // everstake teal + "merlin-official": { color: "#F7A400" }, // merlin amber + "viction-official": { color: "#1D61DE" }, // viction blue + "thundercore-official": { color: "#002868", dark: true }, // thundercore dark + "oktc-official": { color: "#101010", dark: true }, // okx dark + // ─── Stellar ecosystem providers (bench № 210) ─── gateway: { color: "#00C2A8" }, // gateway.fm teal sorobanrpc: { color: "#7B4FBF" }, // sorobanrpc violet diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index 5039533c..df8af222 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -704,6 +704,27 @@ const ALIASES: Record = { "orai-official": "oraichain", "peaq-official": "peaq", + // Non-EVM wave-3 (benches 222-231) — provider-official aliases to chain slug + "ecadinfra": "tezos", + "tzbeta": "tezos", + "tzkt": "tezos", + "greymass": "eos", + "eosnation": "eos", + "alohaeos": "eos", + "vechain-foundation": "vechain", + "vethor-node": "vechain", + "vechain-energy": "vechain", + "wavesnodes": "waves", + "wx-network": "waves", + "waves-exchange": "waves", + "eosusa": "wax", + "waxsweden": "wax", + "neon-p2p": "neon", + "merlin-official": "merlin", + "viction-official": "viction", + "thundercore-official": "thundercore", + "oktc-official": "oktc", + }; export function logoPath(slug: string): string | null { From 30052c8664647f10d3cb36abed17ff7d10a92fcc Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Wed, 19 Aug 2026 12:21:10 +0200 Subject: [PATCH 2/2] restore bridge report (removed by mistake in #2003) --- .../2026-08-state-of-cross-chain-bridges.mdx | 196 ++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 src/content/reports/bridge/2026-08-state-of-cross-chain-bridges.mdx diff --git a/src/content/reports/bridge/2026-08-state-of-cross-chain-bridges.mdx b/src/content/reports/bridge/2026-08-state-of-cross-chain-bridges.mdx new file mode 100644 index 00000000..9870d7e1 --- /dev/null +++ b/src/content/reports/bridge/2026-08-state-of-cross-chain-bridges.mdx @@ -0,0 +1,196 @@ +--- +title: "Best Cross-Chain Bridge 2026: Quote Speed and Real Fees Ranked" +category: "bridge" +slug: "2026-08-state-of-cross-chain-bridges" +publishedAt: "2026-08-18" +period: "August 2026" +summary: "Two live benchmarks across quote latency and effective fees reveal a 10x spread in quote speed between the fastest and slowest providers. Rankings shift by corridor and region. No single provider leads on every measured dimension." +heroFinding: "The spread between the fastest and slowest quote API in this cohort reaches nearly 10x within a 24-hour window. Both settle in the same 15 to 60 second window once the transaction is signed." +author: "OpenChainBench Research" +readingTime: 13 +canonical: "https://openchainbench.com/reports/bridge/2026-08-state-of-cross-chain-bridges" +--- + + +Two live benchmarks across quote APIs and effective fees covering 8 bridge providers on 4 USDC corridors and 3 geographic regions. + +No single provider leads quote speed and fee efficiency simultaneously across all corridors. Rankings shift by direction: Sol to Base and Base to Arb have 6 to 7 competing providers; Arb to Sol and Arb to HyperCore thin to 4. + +Quote latency spans from the low hundreds of milliseconds to over 1,500 ms on identical USDC corridors at aggregate. The ranking shifts by corridor and by region. A provider that leads Sol to Base can trail on Base to Arb. + +Effective fee is not the same as the advertised fee. Total cost at $300 notional (fees plus slippage plus destination gas) is the figure that actually leaves a user's wallet. The cheapest single corridor recorded in this dataset is Sol to Base, with Near Intents consistently quoting below 0.01%. + +Geographic probe region changes results: EU-West returns the tightest latency distributions for most providers in this cohort. + + + + +## Methodology + +Every number in this report is derived from OpenChainBench's live Prometheus instance. Two independent harnesses run continuously: + +The [bridge-quote-latency](/benchmarks/bridge-quote-latency) harness issues identical USDC quote requests against 8 bridge APIs every 5 minutes from 3 geographic regions (EU-West, US-East, Singapore), across 4 corridors (Sol to Base, Base to Arb, Arb to Sol, Arb to HyperCore) and 3 notional sizes ($5, $50, $300). Latency is wall-clock milliseconds from request dispatch to last byte received. Failed quotes are excluded from the latency histogram and counted toward a separate success rate metric. + +The [bridge-fee](/benchmarks/bridge-fee) harness records total cost as a percentage of notional: quoted USD in minus quoted USD delivered, all-in (fees plus slippage plus destination gas). This definition prevents providers that bake cost into a spread from appearing at 0% on explicit-fee-only comparisons. + +All harness source code is open at [github.com/ChainBench/OpenChainBench](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses). + +## Why Quote Latency and Settlement Are Different Numbers + +Most "fastest bridge" comparisons pick one number and ignore the other. + +Quote latency is how fast the bridge API returns a price. It is measured in milliseconds, is determined by server architecture, and is what a wallet's loading spinner reflects. Settlement latency is how long funds take to arrive after the user signs, in seconds to minutes, determined by the source chain's finality model and the bridge's validation mechanism. + +These two numbers are structurally independent. The fastest quote API in this cohort and the slowest produce settlements in nearly the same window once the transaction is signed. This report focuses on the API layer, the part a builder can actually select and tune. + +## Bridge Quote API Speed: Cross-Corridor Aggregate + + + +The fastest providers in this cohort quote at aggregate in the low hundreds of milliseconds. The slowest consistently takes over 1,500 ms on the same corridors. The spread between them reaches nearly 10x within a 24-hour window on the same notional, same corridors, same probe timing. + +Tail latency deserves its own reading. One provider in this cohort posts a p50 at aggregate in the 350 to 400 ms range but a p99 near 5 seconds. That gap means one in a hundred quote requests will sit at the three-second spinner threshold under load, a different risk profile than the p50 alone suggests. Near Intents shows this pattern: its median looks competitive, but the tail reflects the solver auction window firing on uncached routes. + +## Per-Corridor Breakdown + +The aggregate above averages across all four corridors. That average conceals real differences: provider coverage, solver inventory, and routing depth vary sharply by route. The four tables below isolate each corridor. + +### Sol to Base + + + +Solana-origin routes require providers to maintain Solana-aware quoting logic. Six providers cover this corridor. Squid and Socket are absent. The success rate column surfaces who is quoting reliably versus occasionally failing on this route. + +### Base to Arbitrum + + + +Base to Arbitrum is the most contested corridor: a same-ecosystem EVM hop with mature liquidity on both sides. Seven providers compete here, the largest field in the dataset. Providers with pre-staged inventory on both chains quote in under 400 ms; those that enumerate routes across their integrated bridge set take over a second. + +### Arb to Solana + + + +Arbitrum to Solana is the cross-VM route with the thinnest coverage: only 4 providers quote this direction. Squid, Socket, Across, and Near Intents all return unsupported here. The success rate column surfaces who is quoting reliably across the corridor versus occasionally failing. + +### Arb to HyperCore + + + +HyperCore is the newest destination in the harness. Only 4 providers quote this corridor. Near Intents leads here, but that figure reflects a pre-computed price from cached solver inventory. The same bimodal dynamic applies. Providers that lead on Base to Arbitrum do not necessarily lead here. + +## Regional Quote Latency + +Geographic proximity to the bridge API's origin servers predicts quote latency in ways that matter for production integrations. The same provider can rank differently in EU-West versus Singapore. + +### EU-West + + + +EU-West returns the tightest latency distributions in this cohort. Most providers achieve their best or near-best ranking from this region. + +### US-East + + + +### Singapore + + + +Provider rankings shift between regions. Providers without an Asian point of presence carry a visible penalty in the Singapore table. The cross-regional summary below shows which providers hold their rank globally and which degrade as geographic distance grows. + + + +## Architecture and Pricing Models + +Three pricing architectures coexist in this benchmark: + +**Direct protocols** (deBridge) return a pre-computed cost using a native-token fee declared upfront in the quote response. Quote speed is fast. Route optionality is absent by design. deBridge typically ranks among the fastest at aggregate, alongside relay layers. + +**Aggregators** (LI.FI, Squid, Socket) route through whichever underlying bridge is cheapest or fastest at quote time. Their latency reflects route-search complexity. The value proposition is coverage and route optimization, not speed. + +**Relay and intent layers** (Mobula, Relay, Across, Near Intents) bake cost into a spread on a settlement intent or optimistic fill. Quote latency and fee structure are both determined by solver competition, not a fixed fee schedule. Solver-cached routes return fast; uncached routes wait on the auction, which is why p50 and p99 can diverge sharply for the same provider. + +The architectural type predicts both quote latency and fee dynamics more reliably than any other variable in this dataset. An aggregator that covers 30+ underlying bridges will always trade latency for route breadth. That is not an engineering deficit. It is a harder problem solved per request. + +## The True Cost of Bridging + +The cost figure that matters is not the fee field in a bridge's quote object. It is quoted USD in minus quoted USD delivered. Providers that bake cost into a spread appear at 0% on explicit-fee-only comparisons. This benchmark records `bridge_cost_percent`, the all-in number, so spread-based and fee-based pricing land on the same axis. + + + +Two things to read alongside the aggregate table: + +First, **coverage is not uniform**. The lowest-ranked aggregate fee in this table reflects a single corridor covered, not the full four-corridor dataset. The per-corridor tables below put every provider on a level field. + +Second, **success rate matters on fees**. A provider that returns a valid fee quote two-thirds of the time is not a reliable default, regardless of its cost rank on successful calls. Check the success rate column alongside the fee figure. + +At $300 notional, fixed costs (destination gas, base protocol fee) dominate the percentage. A bridge charging $2 in destination gas on a $300 transfer is already at 0.67% before any spread or protocol fee. Published bridge fee tables at $10,000 notional systematically understate what retail users pay at $300. + +## Cost by Corridor + +Effective cost diverges sharply by corridor because solver inventory and destination gas prices vary by chain. The aggregate above is computed across every route each provider covers, but coverage asymmetry means some aggregates are wider samples than others. The per-corridor view below puts every provider on the same four routes. + +### Sol to Base: Effective Fee + + + +Sol to Base is the cheapest corridor in this dataset. The lowest fee recorded on this route is consistently below 0.01%, the tightest all-in cost in the benchmark. The cross-VM boundary (Solana to EVM) does not translate to higher cost when solver inventory is deep on both sides. + +### Base to Arbitrum: Effective Fee + + + +Base to Arbitrum is the liquid EVM corridor where solver competition is strongest. The competitive cluster here is the tightest in the dataset: the middle providers (excluding the fixed-fee outlier) sit within 0.25% of each other, narrowing further at larger notionals. + +### Arb to Solana: Effective Fee + + + +Arb to Sol carries noticeably higher effective fees than Sol to Base despite both crossing the same VM boundary. Direction matters: fewer providers cover this direction. Thinner solver coverage on this direction drives wider spreads, not the VM boundary itself. The most expensive providers on this corridor charge over 10x what the cheapest provider charges on Sol to Base. + +### Arb to HyperCore: Effective Fee + + + +HyperCore is the newest corridor in the bench. Thin solver competition produces the widest effective fees of any route in this dataset. As solver inventory deepens, this table will compress toward the EVM-to-EVM spreads. + +## Decision Framework + + +Quote latency is the primary UX variable. Use the per-region tables (EU-West, US-East, Singapore) to find the current leader for your users' geography, then cross-reference with the per-corridor tables for the specific routes your wallet offers. The aggregate leader may trail on a specific corridor. Parallelize quote requests across 2 to 3 providers and display the fastest valid response. The success rate column is the secondary filter: a bridge with a weak success rate is not a reliable default regardless of its latency rank on successful calls. + + + +Effective fee at your typical notional is the primary variable. The per-corridor cost tables surface where each provider is structurally cheap and where it is not. The aggregate leaderboard at $300 and $10,000 are different rankings. Verify at the size that matches your transfers. Aggregate fee ranks can be misleading when a provider covers fewer corridors than its peers; the per-corridor tables remove that asymmetry. + + + +Aggregators (LI.FI, Socket, Squid) cover more source and destination chain combinations than direct protocols or single-network relay layers. Check the per-corridor success rate column in the quote-latency tables: a provider that shows as available in the aggregate may return `unsupported` on the specific corridor you need. Their broader coverage comes with higher quote latency and, on uncongested corridors, slightly higher effective fees. + + +## Conclusion + +The clearest pattern across both bridge benchmarks is that architecture predicts quote speed and fee structure, but the ranking depends on direction. + +Sol to Base is the cheapest corridor in this dataset. Arb to Sol, the opposite direction across the same VM boundary, is more expensive and has fewer providers. The variable is not the ecosystem boundary; it is how many solvers are actively positioned on that route at the time of the quote. + +No provider leads on every corridor simultaneously. The per-corridor tables make this concrete: aggregate rankings average across coverage asymmetries that matter for real integrations. A provider with strong EVM-to-EVM coverage may be absent on the cross-VM route you need; a provider with deep HyperCore inventory may trail on Base to Arb. + +Production applications typically need at least two providers: one for speed and cost on liquid corridors, one as fallback for niche or cross-VM routes where primary coverage thins. The success rate column in each per-corridor table is the fastest way to identify where each provider's coverage actually holds. + +## Sources + +All data in this report is derived from OpenChainBench's live Prometheus instance. Figures are p50 over a 24-hour rolling window unless noted. Data updates continuously; figures reflect the state as of August 18, 2026. + +**Quote latency:** [bridge-quote-latency](/benchmarks/bridge-quote-latency) · [api/stat/bridge-quote-latency](/api/stat/bridge-quote-latency) + +**Effective fees:** [bridge-fee](/benchmarks/bridge-fee) · [api/stat/bridge-fee](/api/stat/bridge-fee) + +**Bridge hub:** [/bridges](/bridges) · live cross-bench rankings, updated every 5 minutes + +**Harness source:** [github.com/ChainBench/OpenChainBench/harnesses](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses) + +**License:** All data and figures in this report are published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). You may reproduce them with attribution to OpenChainBench and a link to the canonical URL. + +**Corrections:** File a [GitHub issue](https://github.com/ChainBench/OpenChainBench/issues/new). Material corrections are applied in place with a dated note.