From f9eb622e6bed33bf463041bd51a19931d896d9d9 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 20:11:16 +0200 Subject: [PATCH 1/8] feat(rpc): add Sui/Aptos/XRP/Algorand/Gram benches 211-215 --- benchmarks/algorand-rpc.yml | 134 +++++++ benchmarks/aptos-rpc.yml | 157 +++++++++ benchmarks/gram-rpc.yml | 134 +++++++ benchmarks/sui-rpc.yml | 181 ++++++++++ benchmarks/xrp-rpc.yml | 134 +++++++ .../rpc-capabilities/cmd/script/config.go | 58 ++++ .../rpc-capabilities/cmd/script/probe.go | 326 +++++++++++++++++- public/logos/algorand.svg | 4 + src/data/provider-registry.ts | 76 ++++ src/lib/brand.ts | 4 + src/lib/chains.ts | 27 ++ src/lib/logo-manifest.ts | 1 + 12 files changed, 1235 insertions(+), 1 deletion(-) create mode 100644 benchmarks/algorand-rpc.yml create mode 100644 benchmarks/aptos-rpc.yml create mode 100644 benchmarks/gram-rpc.yml create mode 100644 benchmarks/sui-rpc.yml create mode 100644 benchmarks/xrp-rpc.yml create mode 100644 public/logos/algorand.svg diff --git a/benchmarks/algorand-rpc.yml b/benchmarks/algorand-rpc.yml new file mode 100644 index 00000000..546c0b8a --- /dev/null +++ b/benchmarks/algorand-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 214 + +slug: algorand-rpc +number: "214" +title: Fastest free Algorand RPC, live no-key endpoint latency +seo_title: "Fastest free Algorand RPC 2026" +seo_description: "{{best_name}} leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h). 3 no-key providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for the Algorand algod status endpoint (last-round) against every free, no-key public Algorand node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Algorand is an L1 blockchain using a Pure Proof-of-Stake consensus (BA* Byzantine Agreement) that commits one round every roughly 3.5 seconds with immediate finality and no forks. Algorand nodes expose a REST algod API rather than JSON-RPC: GET /v2/status returns the current last-round (equivalent to block height). Free public API endpoints are available without a key from AlgoNode, Nodely and Ankr. Every provider was live-verified with consecutive keyless GET /v2/status probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Algorand. + We measure the round-trip latency of a single REST GET to /v2/status + against every no-key public Algorand algod 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 / stale / timeout) with an Algorand-scaled staleness + gap (90 rounds, around 5 min). The cross-chain view lives on the parent + rpc-capabilities benchmark; this page is the Algorand-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 to /v2/status with Accept: application/json. Pure REST endpoint, no API key in any request. The response JSON includes last-round (integer round number)." + - "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 last-round), http_err, stale (round more than 90 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=algorand. Provider coverage at launch: 3 no-key endpoints (AlgoNode, Nodely, Ankr)." + +findings: + - "{{best_name}} currently leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Algorand RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Algorand algod /v2/status last-round p50 over the last 24h), measured against 3 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Algorand nodes work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: AlgoNode community node, Nodely (formerly AlgoExplorer by Randlabs) and Ankr. Every listed endpoint was live-verified with a GET /v2/status returning a parsable last-round before inclusion." + - q: "Does the fastest Algorand 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 Algorand RPC latency measured here, technically?" + a: "One identical REST GET to /v2/status 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="algorand"}) + +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: algonode + name: AlgoNode + tag: Community-operated free Algorand mainnet API node, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to AlgoNode's mainnet endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="algonode", chain="algorand"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="algonode", chain="algorand"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="algonode", chain="algorand"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="algonode", chain="algorand"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="algonode", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="algonode", chain="algorand"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="algonode", chain="algorand"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="algonode", chain="algorand"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="algonode", chain="algorand", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="algonode", chain="algorand", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="algonode", chain="algorand", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="algonode", chain="algorand", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="algonode", chain="algorand", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="algonode", chain="algorand", region="sgp"}[1h]) + + - slug: nodely + name: Nodely + tag: Nodely (formerly AlgoExplorer by Randlabs), professional Algorand infrastructure, free public tier + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to Nodely's Algorand endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nodely", chain="algorand"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nodely", chain="algorand"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nodely", chain="algorand"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="nodely", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="nodely", chain="algorand"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="nodely", chain="algorand"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="sgp"}[1h]) + + - slug: ankr + name: Ankr + tag: Multi-cloud RPC provider, 50+ chains, public tier with no API key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to Ankr's Algorand endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ankr", chain="algorand"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ankr", chain="algorand"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ankr", chain="algorand"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ankr", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="ankr", chain="algorand"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ankr", chain="algorand"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand", region="sgp"}[1h]) diff --git a/benchmarks/aptos-rpc.yml b/benchmarks/aptos-rpc.yml new file mode 100644 index 00000000..88f17dba --- /dev/null +++ b/benchmarks/aptos-rpc.yml @@ -0,0 +1,157 @@ +# OpenChainBench. Bench No 212 + +slug: aptos-rpc +number: "212" +title: Fastest free Aptos RPC, live no-key endpoint latency +seo_title: "Fastest free Aptos RPC 2026" +seo_description: "{{best_name}} leads free Aptos RPC at {{best_p50}} (REST ledger block_height p50, 24h). 4 no-key providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for the Aptos REST ledger endpoint (block_height) against every free, no-key public Aptos node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Aptos is a Move-based L1 blockchain targeting over 100,000 TPS via Block-STM parallel execution, producing roughly one block per second with sub-second finality. Unlike EVM chains, Aptos exposes a REST API rather than JSON-RPC: GET /v1/ returns the current ledger block_height as a decimal string. Free public API endpoints are available without a key from Aptos Labs, PublicNode, Ankr and NodeReal. Every provider was live-verified with consecutive keyless GET /v1/ probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Aptos. + We measure the round-trip latency of a single REST GET to /v1/ against + every no-key public Aptos node that sustains continuous probing: + 4 providers at launch, every 60 seconds, from us-east, eu-west and + Singapore. The harness classifies every response (ok / http_err / + stale / timeout) with an Aptos-scaled staleness gap (300 blocks, + around 5 min). The cross-chain view lives on the parent + rpc-capabilities benchmark; this page is the Aptos-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 to /v1/ with Accept: application/json. Pure REST endpoint, no API key in any request. The response JSON includes block_height (decimal string) and ledger_version." + - "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_height), http_err, stale (block more than 300 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=aptos. Provider coverage at launch: 4 no-key endpoints (Aptos Labs, PublicNode, Ankr, NodeReal)." + +findings: + - "{{best_name}} currently leads free Aptos RPC at {{best_p50}} (ledger block_height p50, 24h) across 4 measured providers." + +faq: + - q: "What is the fastest free Aptos RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Aptos REST /v1/ block_height p50 over the last 24h), measured against 4 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Aptos nodes work without an API key?" + a: "4 endpoints sustain continuous keyless probing at launch: Aptos Labs official node, PublicNode, Ankr and NodeReal. Every listed endpoint was live-verified with a GET /v1/ returning a parsable block_height before inclusion." + - q: "Does the fastest Aptos 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 Aptos RPC latency measured here, technically?" + a: "One identical REST GET to /v1/ 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="aptos"}) + +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: aptoslabs + name: Aptos Labs + tag: Official Aptos Labs public mainnet node, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to the Aptos Labs official endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptoslabs", chain="aptos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="aptoslabs", chain="aptos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="aptoslabs", chain="aptos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="aptoslabs", chain="aptos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="aptoslabs", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="aptoslabs", chain="aptos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="aptoslabs", chain="aptos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="aptoslabs", chain="aptos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptoslabs", chain="aptos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="aptoslabs", chain="aptos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptoslabs", chain="aptos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="aptoslabs", chain="aptos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptoslabs", chain="aptos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="aptoslabs", chain="aptos", region="sgp"}[1h]) + + - slug: publicnode + name: PublicNode + tag: High-uptime community RPC provider, 25+ chains, no key required, operated by Allnodes + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to PublicNode's Aptos endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="publicnode", chain="aptos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="publicnode", chain="aptos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="publicnode", chain="aptos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="publicnode", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="publicnode", chain="aptos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="publicnode", chain="aptos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos", region="sgp"}[1h]) + + - slug: ankr + name: Ankr + tag: Multi-cloud RPC provider, 50+ chains, public tier with no API key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to Ankr's Aptos endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ankr", chain="aptos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ankr", chain="aptos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ankr", chain="aptos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ankr", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="ankr", chain="aptos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ankr", chain="aptos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos", region="sgp"}[1h]) + + - slug: nodereal + name: NodeReal + tag: Enterprise-grade multi-chain infrastructure, public Aptos endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to NodeReal's Aptos endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nodereal", chain="aptos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nodereal", chain="aptos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nodereal", chain="aptos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="nodereal", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="nodereal", chain="aptos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="nodereal", chain="aptos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos", region="sgp"}[1h]) diff --git a/benchmarks/gram-rpc.yml b/benchmarks/gram-rpc.yml new file mode 100644 index 00000000..582ac1c5 --- /dev/null +++ b/benchmarks/gram-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 215 + +slug: gram-rpc +number: "215" +title: Fastest free Gram RPC, live no-key endpoint latency +seo_title: "Fastest free Gram (TON) RPC 2026" +seo_description: "{{best_name}} leads free Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for getMasterchainInfo against every available public Gram (TON) node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Gram (formerly TON/Toncoin) is a high-throughput L1 blockchain using the BAG (Byzantine Agreement for Gram) consensus protocol and a multi-workchain architecture anchored by a masterchain. The masterchain seqno advances roughly every 5 seconds with deterministic finality. Public JSON-RPC endpoints are available from TON Center (keyless at 1 req/s), dRPC and NOWNodes. Every provider was live-verified with consecutive getMasterchainInfo probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Gram. + We measure the round-trip latency of a single JSON-RPC call + (getMasterchainInfo) against every available public Gram 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 + Gram-scaled staleness gap (60 seqnos, around 5 min). The cross-chain + view lives on the parent rpc-capabilities benchmark; this page is the + Gram-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\":\"getMasterchainInfo\",\"params\":{}}. Plain HTTP POST. The harness handles both the toncenter {ok,result} envelope and standard JSON-RPC 2.0 responses from other providers." + - "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 result.last.seqno), http_err, jsonrpc_err, stale (seqno more than 60 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=gram. Provider coverage at launch: 3 endpoints (TON Center, dRPC, NOWNodes)." + +findings: + - "{{best_name}} currently leads Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Gram (TON) RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (getMasterchainInfo seqno 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 Gram RPC endpoints work without an API key?" + a: "TON Center provides keyless access at up to 1 request per second, which fits our 60-second probe cadence exactly. dRPC and NOWNodes may require a key for sustained access. Every listed endpoint was live-verified with a getMasterchainInfo call returning a parsable seqno before inclusion." + - q: "Does the fastest Gram 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 Gram RPC latency measured here, technically?" + a: "One getMasterchainInfo 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="gram"}) + +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: toncenter + name: TON Center + tag: TON Center public HTTP API v2, keyless at 1 req/s, operated by the TON Foundation + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to TON Center's public endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="toncenter", chain="gram"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="toncenter", chain="gram"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="toncenter", chain="gram"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="toncenter", chain="gram"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="toncenter", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="toncenter", chain="gram"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="toncenter", chain="gram"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="toncenter", chain="gram"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="toncenter", chain="gram", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="toncenter", chain="gram", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="toncenter", chain="gram", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="toncenter", chain="gram", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="toncenter", chain="gram", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="toncenter", chain="gram", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: Decentralized RPC mesh, consensus-checked responses, 29+ chains, 210M CU/mo free tier + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to dRPC's Gram endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="gram"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="gram"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="gram"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="gram"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="gram"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram", region="sgp"}[1h]) + + - slug: nownodes + name: NOWNodes + tag: Multi-chain node provider with Gram (TON) support, API key required for sustained access + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to NOWNodes' Gram endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nownodes", chain="gram"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nownodes", chain="gram"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nownodes", chain="gram"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="nownodes", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="nownodes", chain="gram"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="nownodes", chain="gram"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram", region="sgp"}[1h]) diff --git a/benchmarks/sui-rpc.yml b/benchmarks/sui-rpc.yml new file mode 100644 index 00000000..ff796976 --- /dev/null +++ b/benchmarks/sui-rpc.yml @@ -0,0 +1,181 @@ +# OpenChainBench. Bench No 211 + +slug: sui-rpc +number: "211" +title: Fastest free Sui RPC, live no-key endpoint latency +seo_title: "Fastest free Sui RPC 2026" +seo_description: "{{best_name}} leads free Sui RPC at {{best_p50}} (sui_getLatestCheckpointSequenceNumber p50, 24h). 5 no-key providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for sui_getLatestCheckpointSequenceNumber against every free, no-key public Sui RPC endpoint, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Sui is a Move-based L1 blockchain using the Mysticeti DAG-BFT consensus protocol, producing checkpoints every roughly 3 seconds with deterministic sub-second finality. Free public RPC endpoints are available without an API key from Mysten Labs, PublicNode, BlockVision, Suiet and OnFinality. Every provider was live-verified with consecutive keyless sui_getLatestCheckpointSequenceNumber probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Sui. + We measure the round-trip latency of a single, identical JSON-RPC call + (sui_getLatestCheckpointSequenceNumber) against every no-key public Sui + endpoint that sustains continuous probing: 5 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 Sui-scaled staleness gap (100 checkpoints, around 5 min). + The cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the Sui-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\":\"sui_getLatestCheckpointSequenceNumber\",\"params\":[]}. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches." + - "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 + non-empty result with a parsable checkpoint sequence number), http_err, jsonrpc_err (HTTP 200 carrying an error body), stale (checkpoint more than 100 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=sui. Provider coverage at launch: 5 no-key endpoints (Mysten Labs, PublicNode, BlockVision, Suiet, OnFinality)." + +findings: + - "{{best_name}} currently leads free Sui RPC at {{best_p50}} (sui_getLatestCheckpointSequenceNumber p50, 24h) across 5 measured providers." + +faq: + - q: "What is the fastest free Sui RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (sui_getLatestCheckpointSequenceNumber p50 over the last 24h), measured against 5 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Sui RPCs work without an API key?" + a: "5 endpoints sustain continuous keyless probing at launch: Mysten Labs fullnode, PublicNode, BlockVision, Suiet and OnFinality. Every listed endpoint was live-verified with a sui_getLatestCheckpointSequenceNumber POST returning a parsable checkpoint number before inclusion." + - q: "Does the fastest Sui 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 Sui RPC latency measured here, technically?" + a: "One identical sui_getLatestCheckpointSequenceNumber POST every 60 seconds against each provider from each of 3 regions, using the same plain HTTP client the rest of the RPC cluster uses. 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="sui"}) + +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: fullnode + name: Mysten Labs + tag: Official Mysten Labs public Sui fullnode, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single sui_getLatestCheckpointSequenceNumber POST sent every 60s from 3 regions to the Mysten Labs fullnode." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fullnode", chain="sui"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="fullnode", chain="sui"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="fullnode", chain="sui"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="fullnode", chain="sui"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="fullnode", chain="sui"}) / sum(ocb:rpc_call:rate_24h{provider="fullnode", chain="sui"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="fullnode", chain="sui"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="fullnode", chain="sui"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fullnode", chain="sui", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="fullnode", chain="sui", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fullnode", chain="sui", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="fullnode", chain="sui", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fullnode", chain="sui", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="fullnode", chain="sui", region="sgp"}[1h]) + + - slug: publicnode + name: PublicNode + tag: High-uptime community RPC provider, 25+ chains, no key required, operated by Allnodes + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single sui_getLatestCheckpointSequenceNumber POST sent every 60s from 3 regions to PublicNode's Sui endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="sui"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="publicnode", chain="sui"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="publicnode", chain="sui"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="publicnode", chain="sui"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="publicnode", chain="sui"}) / sum(ocb:rpc_call:rate_24h{provider="publicnode", chain="sui"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="publicnode", chain="sui"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="sui"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="sui", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="sui", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="sui", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="sui", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="sui", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="sui", region="sgp"}[1h]) + + - slug: blockvision + name: BlockVision + tag: High-throughput Sui mainnet RPC by BlockVision, public endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single sui_getLatestCheckpointSequenceNumber POST sent every 60s from 3 regions to BlockVision's Sui endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockvision", chain="sui"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="blockvision", chain="sui"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="blockvision", chain="sui"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="blockvision", chain="sui"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="blockvision", chain="sui"}) / sum(ocb:rpc_call:rate_24h{provider="blockvision", chain="sui"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="blockvision", chain="sui"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="blockvision", chain="sui"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockvision", chain="sui", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="blockvision", chain="sui", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockvision", chain="sui", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="blockvision", chain="sui", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockvision", chain="sui", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="blockvision", chain="sui", region="sgp"}[1h]) + + - slug: suiet + name: Suiet + tag: Suiet wallet-operated public Sui RPC, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single sui_getLatestCheckpointSequenceNumber POST sent every 60s from 3 regions to Suiet's Sui endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="suiet", chain="sui"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="suiet", chain="sui"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="suiet", chain="sui"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="suiet", chain="sui"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="suiet", chain="sui"}) / sum(ocb:rpc_call:rate_24h{provider="suiet", chain="sui"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="suiet", chain="sui"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="suiet", chain="sui"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="suiet", chain="sui", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="suiet", chain="sui", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="suiet", chain="sui", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="suiet", chain="sui", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="suiet", chain="sui", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="suiet", chain="sui", region="sgp"}[1h]) + + - slug: onfinality + name: OnFinality + tag: Global multi-chain gateway, 70+ networks, rate-limited public tier, 5 req/sec + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single sui_getLatestCheckpointSequenceNumber POST sent every 60s from 3 regions to OnFinality's Sui endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="sui"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="onfinality", chain="sui"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="onfinality", chain="sui"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="onfinality", chain="sui"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="onfinality", chain="sui"}) / sum(ocb:rpc_call:rate_24h{provider="onfinality", chain="sui"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="onfinality", chain="sui"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="sui"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="sui", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="sui", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="sui", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="sui", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="sui", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="sui", region="sgp"}[1h]) diff --git a/benchmarks/xrp-rpc.yml b/benchmarks/xrp-rpc.yml new file mode 100644 index 00000000..01685411 --- /dev/null +++ b/benchmarks/xrp-rpc.yml @@ -0,0 +1,134 @@ +# OpenChainBench. Bench No 213 + +slug: xrp-rpc +number: "213" +title: Fastest free XRP Ledger RPC, live no-key endpoint latency +seo_title: "Fastest free XRP Ledger RPC 2026" +seo_description: "{{best_name}} leads free XRP Ledger RPC at {{best_p50}} (ledger_current p50, 24h). 3 no-key providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for ledger_current against every free, no-key public XRP Ledger node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + The XRP Ledger is a decentralized payment network using a federated consensus protocol (RPCA) that closes a new ledger every 3 to 4 seconds with instant, deterministic finality. Free public JSON-RPC endpoints are available without an API key from Ripple, XRPL Labs and PublicNode. Every provider was live-verified with consecutive keyless ledger_current probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to XRP Ledger. + We measure the round-trip latency of a single JSON-RPC call + (ledger_current) against every no-key public XRP Ledger 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 + XRPL-scaled staleness gap (75 ledgers, around 5 min). The cross-chain + view lives on the parent rpc-capabilities benchmark; this page is the + XRP-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: {\"method\":\"ledger_current\",\"params\":[{}]}. Plain HTTP POST. XRPL uses its own JSON-RPC envelope (no jsonrpc:2.0 field); errors are signalled via result.status='error'. Non-cacheable by design." + - "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 + result.ledger_current_index present and non-zero), http_err, jsonrpc_err, stale (ledger more than 75 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=xrp. Provider coverage at launch: 3 no-key endpoints (Ripple, XRPL Labs, PublicNode)." + +findings: + - "{{best_name}} currently leads free XRP Ledger RPC at {{best_p50}} (ledger_current p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free XRP Ledger RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (XRPL ledger_current p50 over the last 24h), measured against 3 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which XRP Ledger nodes work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Ripple's public s1 node, XRPL Labs cluster and PublicNode. Every listed endpoint was live-verified with a ledger_current POST returning a parsable ledger index before inclusion." + - q: "Does the fastest XRP 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 XRP Ledger RPC latency measured here, technically?" + a: "One identical ledger_current POST 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="xrp"}) + +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: ripple + name: Ripple + tag: Ripple-operated public XRP Ledger mainnet node (s1), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a ledger_current POST sent every 60s from 3 regions to Ripple's public s1 node." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ripple", chain="xrp"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ripple", chain="xrp"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ripple", chain="xrp"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ripple", chain="xrp"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ripple", chain="xrp"}) / sum(ocb:rpc_call:rate_24h{provider="ripple", chain="xrp"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ripple", chain="xrp"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ripple", chain="xrp"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ripple", chain="xrp", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ripple", chain="xrp", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ripple", chain="xrp", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ripple", chain="xrp", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ripple", chain="xrp", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ripple", chain="xrp", region="sgp"}[1h]) + + - slug: xrpl-labs + name: XRPL Labs + tag: XRPL Labs cluster (xrplcluster.com), community-operated XRPL Foundation nodes, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a ledger_current POST sent every 60s from 3 regions to the XRPL Labs cluster." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="xrpl-labs", chain="xrp"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="xrpl-labs", chain="xrp"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="xrpl-labs", chain="xrp"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="xrpl-labs", chain="xrp"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="xrpl-labs", chain="xrp"}) / sum(ocb:rpc_call:rate_24h{provider="xrpl-labs", chain="xrp"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="xrpl-labs", chain="xrp"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="xrpl-labs", chain="xrp"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="xrpl-labs", chain="xrp", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="xrpl-labs", chain="xrp", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="xrpl-labs", chain="xrp", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="xrpl-labs", chain="xrp", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="xrpl-labs", chain="xrp", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="xrpl-labs", chain="xrp", region="sgp"}[1h]) + + - slug: publicnode + name: PublicNode + tag: High-uptime community RPC provider, 25+ chains, no key required, operated by Allnodes + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a ledger_current POST sent every 60s from 3 regions to PublicNode's XRP Ledger endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="xrp"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="publicnode", chain="xrp"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="publicnode", chain="xrp"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="publicnode", chain="xrp"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="publicnode", chain="xrp"}) / sum(ocb:rpc_call:rate_24h{provider="publicnode", chain="xrp"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="publicnode", chain="xrp"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="xrp"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="xrp", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="xrp", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="xrp", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="xrp", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="xrp", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="xrp", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index 6553a96c..91e3193a 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -1494,6 +1494,64 @@ func chains() []Chain { {Slug: "lightsail", Name: "Lightsail Network", URL: envDefault("RPC_URL_STELLAR_LIGHTSAIL", "https://rpc.lightsail.network/")}, }, }, + // Sui — Mysticeti DAG-BFT, sui_getLatestCheckpointSequenceNumber, ~3 s checkpoint. 5 keyless providers. + { + Slug: "sui", + Name: "Sui", + Kind: "sui", + Providers: []Provider{ + {Slug: "fullnode", Name: "Mysten Labs", URL: envDefault("RPC_URL_SUI_FULLNODE", "https://fullnode.mainnet.sui.io")}, + {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_SUI_PUBLICNODE", "https://sui-rpc.publicnode.com")}, + {Slug: "blockvision", Name: "BlockVision", URL: envDefault("RPC_URL_SUI_BLOCKVISION", "https://sui-mainnet-endpoint.blockvision.org")}, + {Slug: "suiet", Name: "Suiet", URL: envDefault("RPC_URL_SUI_SUIET", "https://mainnet.suiet.app")}, + {Slug: "onfinality", Name: "OnFinality", URL: envDefault("RPC_URL_SUI_ONFINALITY", "https://sui.api.onfinality.io/public")}, + }, + }, + // Aptos — Move VM, REST GET /v1/ block_height probe, ~1 block/s. 3 keyless providers. + { + Slug: "aptos", + Name: "Aptos", + Kind: "aptos", + Providers: []Provider{ + {Slug: "aptoslabs", Name: "Aptos Labs", URL: envDefault("RPC_URL_APTOS_APTOSLABS", "https://api.mainnet.aptoslabs.com/v1/")}, + {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_APTOS_PUBLICNODE", "https://aptos-mainnet.publicnode.com/v1/")}, + {Slug: "ankr", Name: "Ankr", URL: envDefault("RPC_URL_APTOS_ANKR", "https://rpc.ankr.com/http/aptos/v1")}, + {Slug: "nodereal", Name: "NodeReal", URL: envDefault("RPC_URL_APTOS_NODEREAL", "https://aptos-mainnet.nodereal.io/v1/")}, + }, + }, + // XRP Ledger — ledger_current JSON-RPC probe, ~3-4 s ledger close. 3 keyless providers. + { + Slug: "xrp", + Name: "XRP Ledger", + Kind: "xrpl", + Providers: []Provider{ + {Slug: "ripple", Name: "Ripple", URL: envDefault("RPC_URL_XRP_RIPPLE", "https://s1.ripple.com:51234")}, + {Slug: "xrpl-labs", Name: "XRPL Labs", URL: envDefault("RPC_URL_XRP_XRPLLABS", "https://xrplcluster.com")}, + {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_XRP_PUBLICNODE", "https://xrp-rpc.publicnode.com")}, + }, + }, + // Algorand — REST GET /v2/status last-round probe, ~3.5 s per round. 2 keyless providers. + { + Slug: "algorand", + Name: "Algorand", + Kind: "algorand", + Providers: []Provider{ + {Slug: "algonode", Name: "AlgoNode", URL: envDefault("RPC_URL_ALGORAND_ALGONODE", "https://mainnet-api.algonode.cloud")}, + {Slug: "nodely", Name: "Nodely", URL: envDefault("RPC_URL_ALGORAND_NODELY", "https://mainnet-api.4160.nodely.io")}, + {Slug: "ankr", Name: "Ankr", URL: envDefault("RPC_URL_ALGORAND_ANKR", "https://rpc.ankr.com/algorand")}, + }, + }, + // Gram — TON masterchain, getMasterchainInfo JSON-RPC, ~5 s seqno. 3 providers (toncenter keyless). + { + Slug: "gram", + Name: "Gram", + Kind: "gram", + Providers: []Provider{ + {Slug: "toncenter", Name: "TON Center", URL: envDefault("RPC_URL_GRAM_TONCENTER", "https://toncenter.com/api/v2/jsonRPC")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_GRAM_DRPC", "https://ton.drpc.org")}, + {Slug: "nownodes", Name: "NOWNodes", URL: envDefault("RPC_URL_GRAM_NOWNODES", "https://ton.nownodes.io/jsonRPC")}, + }, + }, } 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 a3d85dec..dfd931ee 100644 --- a/harnesses/rpc-capabilities/cmd/script/probe.go +++ b/harnesses/rpc-capabilities/cmd/script/probe.go @@ -49,6 +49,21 @@ const ( // stellarStaleLedgerGap: Stellar closes a ledger every ~5 s, so // 60 ledgers ≈ 5 min gives the same tolerance as EVM at 12 s/block. stellarStaleLedgerGap uint64 = 60 + // suiStaleCheckpointGap: Sui checkpoints are produced every ~3 s, + // so 100 checkpoints ≈ 5 min gives the same order of tolerance. + suiStaleCheckpointGap uint64 = 100 + // aptosStaleBlockGap: Aptos produces roughly one block per second, + // so 300 blocks ≈ 5 min. + aptosStaleBlockGap uint64 = 300 + // xrplStaleLedgerGap: XRP Ledger closes every ~3-4 s, so 75 ledgers + // ≈ 5 min. + xrplStaleLedgerGap uint64 = 75 + // algorandStaleRoundGap: Algorand commits one round every ~3.5 s, + // so 90 rounds ≈ 5 min. + algorandStaleRoundGap uint64 = 90 + // gramStaleSeqnoGap: TON/Gram masterchain seqno advances every ~5 s, + // so 60 seqnos ≈ 5 min. + gramStaleSeqnoGap uint64 = 60 ) // chainTips tracks the highest block seen for each chain across all @@ -217,6 +232,16 @@ func probeOne(ctx context.Context, c Chain, p Provider) { block, result, latency, err = callStarknetBlockNumber(probeCtx, p.URL) case "stellar": block, result, latency, err = callStellarLatestLedger(probeCtx, p.URL) + case "sui": + block, result, latency, err = callSuiCheckpoint(probeCtx, p.URL) + case "aptos": + block, result, latency, err = callAptosLedger(probeCtx, p.URL) + case "xrpl": + block, result, latency, err = callXrplLedger(probeCtx, p.URL) + case "algorand": + block, result, latency, err = callAlgorandStatus(probeCtx, p.URL) + case "gram": + block, result, latency, err = callGramSeqno(probeCtx, p.URL) default: block, hash, result, latency, err = callLatestBlock(probeCtx, p.URL) } @@ -236,6 +261,16 @@ func probeOne(ctx context.Context, c Chain, p Provider) { gap = starknetStaleBlockGap case "stellar": gap = stellarStaleLedgerGap + case "sui": + gap = suiStaleCheckpointGap + case "aptos": + gap = aptosStaleBlockGap + case "xrpl": + gap = xrplStaleLedgerGap + case "algorand": + gap = algorandStaleRoundGap + case "gram": + gap = gramStaleSeqnoGap } if tip > 0 && block+gap < tip { result = "stale" @@ -254,7 +289,8 @@ func probeOne(ctx context.Context, c Chain, p Provider) { // the reliability change surface small — revisit once the // hash normalisation across Cosmos chains is validated). switch c.Kind { - case "solana", "polkadot", "cosmos", "starknet", "stellar": + case "solana", "polkadot", "cosmos", "starknet", "stellar", + "sui", "aptos", "xrpl", "algorand", "gram": // no consensus participation default: if result == "ok" || result == "stale" { @@ -563,6 +599,53 @@ type stellarLedger struct { Sequence uint64 `json:"sequence"` } +// suiCheckpointResult is the shape of sui_getLatestCheckpointSequenceNumber result. +// The RPC returns the sequence number as a decimal string. +type suiCheckpointResult struct { + Result string `json:"result"` + Error *struct { + Code int `json:"code"` + Message string `json:"message"` + } `json:"error"` +} + +// aptosLedgerInfo is the shape of GET /v1/ on an Aptos REST node. +type aptosLedgerInfo struct { + BlockHeight string `json:"block_height"` +} + +// xrplLedgerCurrentResp is the HTTP JSON-RPC response for ledger_current. +// XRPL does not use jsonrpc:2.0 — error signal is result.status="error". +type xrplLedgerCurrentResp struct { + Result struct { + LedgerCurrentIndex uint64 `json:"ledger_current_index"` + Status string `json:"status"` + ErrorMessage string `json:"error_message"` + } `json:"result"` +} + +// algorandStatus is the shape of GET /v2/status on an Algorand algod node. +type algorandStatus struct { + LastRound uint64 `json:"last-round"` +} + +// gramApiResp handles both toncenter's {ok,result,...} envelope and plain +// JSON-RPC 2.0 {result,...} responses from other TON providers. +type gramApiResp struct { + OK *bool `json:"ok"` + Result json.RawMessage `json:"result"` + Error *struct { + Code int `json:"code"` + Message string `json:"message"` + } `json:"error"` +} + +type gramMasterchainInfo struct { + Last struct { + Seqno uint64 `json:"seqno"` + } `json:"last"` +} + // callStellarLatestLedger is the Stellar Soroban RPC probe path: getLatestLedger // with a rotating request id. Returns the ledger sequence as block number. // Staleness uses stellarStaleLedgerGap in probeOne. @@ -616,3 +699,244 @@ func callStellarLatestLedger(ctx context.Context, url string) (ledger uint64, re } return sl.Sequence, "ok", latencyMs, nil } + +// callSuiCheckpoint probes a Sui full-node using sui_getLatestCheckpointSequenceNumber. +// The result is a decimal string; staleness uses suiStaleCheckpointGap in probeOne. +func callSuiCheckpoint(ctx context.Context, url string) (seq uint64, result string, latencyMs float64, err error) { + body := []byte(fmt.Sprintf( + `{"jsonrpc":"2.0","method":"sui_getLatestCheckpointSequenceNumber","params":[],"id":%d}`, + time.Now().UnixNano(), + )) + req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body)) + req.Header.Set("Content-Type", "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 r suiCheckpointResult + if err := json.Unmarshal(raw, &r); err != nil { + return 0, "http_err", latencyMs, err + } + if r.Error != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("rpc -%d: %s", r.Error.Code, r.Error.Message) + } + seqStr := strings.Trim(r.Result, `"`) + if seqStr == "" || seqStr == "null" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("empty checkpoint result") + } + n, err := strconv.ParseUint(seqStr, 10, 64) + if err != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("non-numeric checkpoint: %s", seqStr[:min(len(seqStr), 40)]) + } + return n, "ok", latencyMs, nil +} + +// callAptosLedger probes an Aptos full-node via the REST ledger info endpoint (GET /v1/). +// block_height is a decimal string in the response body. +// Staleness uses aptosStaleBlockGap in probeOne. +func callAptosLedger(ctx context.Context, url string) (height uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + if !strings.HasSuffix(target, "/v1") { + target = target + "/v1" + } + 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 aptosLedgerInfo + if err := json.Unmarshal(raw, &info); err != nil { + return 0, "http_err", latencyMs, err + } + if info.BlockHeight == "" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("aptos ledger missing block_height") + } + n, err := strconv.ParseUint(info.BlockHeight, 10, 64) + if err != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("non-numeric block_height: %s", info.BlockHeight[:min(len(info.BlockHeight), 40)]) + } + return n, "ok", latencyMs, nil +} + +// callXrplLedger probes an XRP Ledger node using the ledger_current JSON-RPC method. +// XRPL uses its own JSON-RPC envelope (no jsonrpc:2.0 field; error lives in result.status). +// Staleness uses xrplStaleLedgerGap in probeOne. +func callXrplLedger(ctx context.Context, url string) (idx uint64, result string, latencyMs float64, err error) { + body := []byte(`{"method":"ledger_current","params":[{}]}`) + req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body)) + req.Header.Set("Content-Type", "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 r xrplLedgerCurrentResp + if err := json.Unmarshal(raw, &r); err != nil { + return 0, "http_err", latencyMs, err + } + if r.Result.Status == "error" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("xrpl error: %s", r.Result.ErrorMessage) + } + if r.Result.LedgerCurrentIndex == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("xrpl missing ledger_current_index") + } + return r.Result.LedgerCurrentIndex, "ok", latencyMs, nil +} + +// callAlgorandStatus probes an Algorand algod node via REST GET /v2/status. +// last-round is the latest committed round (analogous to block height). +// Staleness uses algorandStaleRoundGap in probeOne. +func callAlgorandStatus(ctx context.Context, url string) (round uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/v2/status" + 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 s algorandStatus + if err := json.Unmarshal(raw, &s); err != nil { + return 0, "http_err", latencyMs, err + } + if s.LastRound == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("algorand status missing last-round") + } + return s.LastRound, "ok", latencyMs, nil +} + +// callGramSeqno probes a TON/Gram node via getMasterchainInfo JSON-RPC. +// Handles both toncenter's {ok,result,...} envelope and plain JSON-RPC 2.0. +// Staleness uses gramStaleSeqnoGap in probeOne. +func callGramSeqno(ctx context.Context, url string) (seqno uint64, result string, latencyMs float64, err error) { + body := []byte(fmt.Sprintf( + `{"jsonrpc":"2.0","method":"getMasterchainInfo","params":{},"id":%d}`, + time.Now().UnixNano(), + )) + req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body)) + req.Header.Set("Content-Type", "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 gr gramApiResp + if err := json.Unmarshal(raw, &gr); err != nil { + return 0, "http_err", latencyMs, err + } + if gr.Error != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("rpc -%d: %s", gr.Error.Code, gr.Error.Message) + } + if gr.OK != nil && !*gr.OK { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("toncenter ok=false") + } + if len(gr.Result) == 0 || string(gr.Result) == "null" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("empty gram result") + } + var mc gramMasterchainInfo + if err := json.Unmarshal(gr.Result, &mc); err != nil { + return 0, "jsonrpc_err", latencyMs, err + } + if mc.Last.Seqno == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("gram masterchain missing seqno") + } + return mc.Last.Seqno, "ok", latencyMs, nil +} diff --git a/public/logos/algorand.svg b/public/logos/algorand.svg new file mode 100644 index 00000000..584ee79f --- /dev/null +++ b/public/logos/algorand.svg @@ -0,0 +1,4 @@ + + + AL + diff --git a/src/data/provider-registry.ts b/src/data/provider-registry.ts index 9e696587..7180dea8 100644 --- a/src/data/provider-registry.ts +++ b/src/data/provider-registry.ts @@ -2190,6 +2190,82 @@ export const PROVIDER_REGISTRY: Record = { "Lightsail Network operates Quasar, a multi-endpoint Stellar infrastructure suite offering a public no-key Soroban RPC (rpc.lightsail.network) and a full archive RPC (archive-rpc.lightsail.network) for Stellar mainnet.", twitter: "@lightsailnet", }, + + // ─── Sui providers (bench 211) ─── + fullnode: { + url: "https://sui.io", + description: + "Official Mysten Labs public Sui fullnode. No API key required; operated by Mysten Labs (the core Sui developer) as the canonical reference endpoint for the Sui mainnet.", + twitter: "@SuiNetwork", + }, + blockvision: { + url: "https://blockvision.org", + description: + "BlockVision provides high-throughput node infrastructure and data APIs for Sui and other chains. The public mainnet endpoint requires no API key and supports the full Sui JSON-RPC surface.", + twitter: "@BlockVision_io", + }, + suiet: { + url: "https://suiet.app", + description: + "Suiet is an open-source Sui wallet that operates a public Sui mainnet RPC as a community service. No API key required; endpoint is shared with the Suiet wallet's own backend.", + twitter: "@suiet_wallet", + }, + + // ─── Aptos providers (bench 212) ─── + aptoslabs: { + url: "https://aptoslabs.com", + description: + "Official Aptos Labs public mainnet node at api.mainnet.aptoslabs.com. No API key required; the canonical reference endpoint maintained by the Aptos Foundation and Aptos Labs.", + twitter: "@AptosLabs", + }, + nodereal: { + url: "https://nodereal.io", + description: + "NodeReal is an enterprise-grade blockchain node provider supporting Aptos and other chains. Offers a public tier with no API key required and paid tiers for higher throughput.", + twitter: "@NodeReal_", + }, + + // ─── XRP Ledger providers (bench 213) ─── + ripple: { + url: "https://ripple.com", + description: + "Ripple operates public XRP Ledger mainnet nodes (s1.ripple.com, s2.ripple.com) as a community service. No API key required; s1 is a stock ledger node and s2 retains full history.", + twitter: "@Ripple", + }, + "xrpl-labs": { + url: "https://xrpl.org", + description: + "XRPL Labs operates the community cluster at xrplcluster.com, a load-balanced set of XRPL Foundation nodes available to developers without any API key. Supports the full XRPL JSON-RPC API.", + twitter: "@XRPLabs", + }, + + // ─── Algorand providers (bench 214) ─── + algonode: { + url: "https://algonode.io", + description: + "AlgoNode is a community-operated free Algorand mainnet node (mainnet-api.algonode.cloud). No API key required; provides both algod (API) and indexer endpoints for the Algorand ecosystem.", + twitter: "@algonode_io", + }, + nodely: { + url: "https://nodely.io", + description: + "Nodely (formerly AlgoExplorer by Randlabs) is a professional Algorand infrastructure provider offering a free public algod API tier at mainnet-api.4160.nodely.io with no API key required.", + twitter: "@nodely_io", + }, + + // ─── Gram/TON providers (bench 215) ─── + toncenter: { + url: "https://toncenter.com", + description: + "TON Center provides the official HTTP API v2 for the TON/Gram blockchain, operated by the TON Foundation. Keyless access is available at 1 request per second; higher rates require an API key.", + twitter: "@toncenter", + }, + nownodes: { + url: "https://nownodes.io", + description: + "NOWNodes is a multi-chain node provider covering Gram (TON), Bitcoin, Ethereum and 50+ other chains. Offers API-key-based access with a free trial tier.", + twitter: "@NOWNodes_io", + }, }; /** diff --git a/src/lib/brand.ts b/src/lib/brand.ts index 14c9ce09..4a85ead7 100644 --- a/src/lib/brand.ts +++ b/src/lib/brand.ts @@ -98,6 +98,10 @@ const BRANDS: Record = { kraken: { color: "#5741D9" }, // kraken purple "binance-us": { color: "#F0B90B" }, // binance yellow + // ─── Non-EVM L1s (benches 211-214) ─── + aptos: { color: "#00C4FF" }, // aptos cyan (brand kit) + algorand: { color: "#00BCD4" }, // algorand teal + // ─── Stellar ecosystem providers (bench № 210) ─── gateway: { color: "#00C2A8" }, // gateway.fm teal sorobanrpc: { color: "#7B4FBF" }, // sorobanrpc violet diff --git a/src/lib/chains.ts b/src/lib/chains.ts index 418c7797..2b8891c4 100644 --- a/src/lib/chains.ts +++ b/src/lib/chains.ts @@ -93,6 +93,33 @@ export const CHAINS: ChainEntry[] = [ description: "Gram (formerly TON / Toncoin). BAG consensus, masterchain + workchains, deterministic finality under one second on the masterchain commit. Native token renamed Toncoin → Gram in June 2026.", }, + { + slug: "aptos", + label: "Aptos", + category: "L1", + nativeSymbol: "APT", + description: + "Move-based L1 using Block-STM parallel execution, targeting 100,000+ TPS, roughly one block per second with sub-second deterministic finality.", + website: "https://aptosfoundation.org", + }, + { + slug: "xrp", + label: "XRP Ledger", + category: "L1", + nativeSymbol: "XRP", + description: + "Federated consensus (RPCA), 3 to 4 second ledger close, deterministic finality without mining, designed for fast cross-border payments.", + website: "https://xrpl.org", + }, + { + slug: "algorand", + label: "Algorand", + category: "L1", + nativeSymbol: "ALGO", + description: + "Pure Proof-of-Stake (BA* Byzantine Agreement), one round every roughly 3.5 seconds, immediate finality with no forks.", + website: "https://algorand.co", + }, { slug: "stellar", label: "Stellar", diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index 2a7482be..59d41823 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -27,6 +27,7 @@ const RAW: Record = { litecoin: "/logos/litecoin.png", monero: "/logos/monero.png", xrp: "/logos/xrp.jpg", + algorand: "/logos/algorand.svg", // ─── EVM L2s & sidechains ─── base: "/logos/base.jpeg", From 9fd2b5a6932dbb0f56a90c822ec03148bd6b5a9e Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 20:24:42 +0200 Subject: [PATCH 2/8] feat(logos): add SVGs + manifest for all 5 new RPC bench providers --- public/logos/algonode.svg | 4 ++++ public/logos/aptoslabs.svg | 4 ++++ public/logos/blockvision.svg | 4 ++++ public/logos/mysten.svg | 4 ++++ public/logos/nodely.svg | 4 ++++ public/logos/nodereal.svg | 4 ++++ public/logos/nownodes.svg | 4 ++++ public/logos/ripple.svg | 4 ++++ public/logos/suiet.svg | 4 ++++ public/logos/toncenter.svg | 4 ++++ public/logos/xrpl-labs.svg | 4 ++++ src/lib/logo-manifest.ts | 16 ++++++++++++++++ 12 files changed, 60 insertions(+) create mode 100644 public/logos/algonode.svg create mode 100644 public/logos/aptoslabs.svg create mode 100644 public/logos/blockvision.svg create mode 100644 public/logos/mysten.svg create mode 100644 public/logos/nodely.svg create mode 100644 public/logos/nodereal.svg create mode 100644 public/logos/nownodes.svg create mode 100644 public/logos/ripple.svg create mode 100644 public/logos/suiet.svg create mode 100644 public/logos/toncenter.svg create mode 100644 public/logos/xrpl-labs.svg diff --git a/public/logos/algonode.svg b/public/logos/algonode.svg new file mode 100644 index 00000000..c530adac --- /dev/null +++ b/public/logos/algonode.svg @@ -0,0 +1,4 @@ + + + AN + diff --git a/public/logos/aptoslabs.svg b/public/logos/aptoslabs.svg new file mode 100644 index 00000000..38cc1abe --- /dev/null +++ b/public/logos/aptoslabs.svg @@ -0,0 +1,4 @@ + + + AL + diff --git a/public/logos/blockvision.svg b/public/logos/blockvision.svg new file mode 100644 index 00000000..ae3cfd53 --- /dev/null +++ b/public/logos/blockvision.svg @@ -0,0 +1,4 @@ + + + BV + diff --git a/public/logos/mysten.svg b/public/logos/mysten.svg new file mode 100644 index 00000000..2aec5d2c --- /dev/null +++ b/public/logos/mysten.svg @@ -0,0 +1,4 @@ + + + ML + diff --git a/public/logos/nodely.svg b/public/logos/nodely.svg new file mode 100644 index 00000000..00373ac1 --- /dev/null +++ b/public/logos/nodely.svg @@ -0,0 +1,4 @@ + + + ND + diff --git a/public/logos/nodereal.svg b/public/logos/nodereal.svg new file mode 100644 index 00000000..45bf8870 --- /dev/null +++ b/public/logos/nodereal.svg @@ -0,0 +1,4 @@ + + + NR + diff --git a/public/logos/nownodes.svg b/public/logos/nownodes.svg new file mode 100644 index 00000000..297c5a4e --- /dev/null +++ b/public/logos/nownodes.svg @@ -0,0 +1,4 @@ + + + NN + diff --git a/public/logos/ripple.svg b/public/logos/ripple.svg new file mode 100644 index 00000000..f7553991 --- /dev/null +++ b/public/logos/ripple.svg @@ -0,0 +1,4 @@ + + + RI + diff --git a/public/logos/suiet.svg b/public/logos/suiet.svg new file mode 100644 index 00000000..9f7f1637 --- /dev/null +++ b/public/logos/suiet.svg @@ -0,0 +1,4 @@ + + + SU + diff --git a/public/logos/toncenter.svg b/public/logos/toncenter.svg new file mode 100644 index 00000000..ac5a32f4 --- /dev/null +++ b/public/logos/toncenter.svg @@ -0,0 +1,4 @@ + + + TC + diff --git a/public/logos/xrpl-labs.svg b/public/logos/xrpl-labs.svg new file mode 100644 index 00000000..14d72f1f --- /dev/null +++ b/public/logos/xrpl-labs.svg @@ -0,0 +1,4 @@ + + + XL + diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index 59d41823..c78f3136 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -164,6 +164,22 @@ const RAW: Record = { // ─── Public RPC providers ─── publicnode: "/logos/publicnode.png", + // ─── Sui providers (bench 211) ─── + fullnode: "/logos/mysten.svg", + blockvision: "/logos/blockvision.svg", + suiet: "/logos/suiet.svg", + // ─── Aptos providers (bench 212) ─── + aptoslabs: "/logos/aptoslabs.svg", + nodereal: "/logos/nodereal.svg", + // ─── XRP providers (bench 213) ─── + ripple: "/logos/ripple.svg", + "xrpl-labs": "/logos/xrpl-labs.svg", + // ─── Algorand providers (bench 214) ─── + algonode: "/logos/algonode.svg", + nodely: "/logos/nodely.svg", + // ─── Gram/TON providers (bench 215) ─── + toncenter: "/logos/toncenter.svg", + nownodes: "/logos/nownodes.svg", infura: "/logos/infura.png", ankr: "/logos/ankr.png", chainstack: "/logos/chainstack.svg", From 7934aef0b7bb340080b2a96577521f575bb24d03 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 20:43:27 +0200 Subject: [PATCH 3/8] fix(rpc): reduce aptos/algorand/gram to verified-free providers only Aptos: keep aptoslabs + aptos-fullnode (2 working endpoints). Algorand: keep algonode only (nodely/ankr require keys or return 4xx). Gram: keep toncenter only (drpc/nownodes 404/401). Update YAMLs and add aptos-fullnode to logo manifest and provider registry. --- benchmarks/algorand-rpc.yml | 60 ++---------- benchmarks/aptos-rpc.yml | 94 +++++-------------- benchmarks/gram-rpc.yml | 60 ++---------- .../rpc-capabilities/cmd/script/config.go | 14 +-- src/data/provider-registry.ts | 7 ++ src/lib/logo-manifest.ts | 1 + 6 files changed, 50 insertions(+), 186 deletions(-) diff --git a/benchmarks/algorand-rpc.yml b/benchmarks/algorand-rpc.yml index 546c0b8a..d99c7d26 100644 --- a/benchmarks/algorand-rpc.yml +++ b/benchmarks/algorand-rpc.yml @@ -4,7 +4,7 @@ slug: algorand-rpc number: "214" title: Fastest free Algorand RPC, live no-key endpoint latency seo_title: "Fastest free Algorand RPC 2026" -seo_description: "{{best_name}} leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h). 3 no-key providers measured every 60s from 3 regions." +seo_description: "{{best_name}} leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h). Measured every 60s from 3 regions." subtitle: HTTP round-trip latency for the Algorand algod status endpoint (last-round) against every free, no-key public Algorand node, audited every 60 seconds from 3 regions. category: RPCs @@ -14,13 +14,13 @@ unit: ms higher_is_better: false seo_intro: | - Algorand is an L1 blockchain using a Pure Proof-of-Stake consensus (BA* Byzantine Agreement) that commits one round every roughly 3.5 seconds with immediate finality and no forks. Algorand nodes expose a REST algod API rather than JSON-RPC: GET /v2/status returns the current last-round (equivalent to block height). Free public API endpoints are available without a key from AlgoNode, Nodely and Ankr. Every provider was live-verified with consecutive keyless GET /v2/status probes at launch. + Algorand is an L1 blockchain using a Pure Proof-of-Stake consensus (BA* Byzantine Agreement) that commits one round every roughly 3.5 seconds with immediate finality and no forks. Algorand nodes expose a REST algod API rather than JSON-RPC: GET /v2/status returns the current last-round (equivalent to block height). The AlgoNode community endpoint is available free without a key. Every provider was live-verified with consecutive keyless GET /v2/status probes at launch. abstract: | Per-chain member of the RPC latency cluster, extended to Algorand. We measure the round-trip latency of a single REST GET to /v2/status against every no-key public Algorand algod node that sustains - continuous probing: 3 providers at launch, every 60 seconds, from + continuous probing: 1 provider at launch, every 60 seconds, from us-east, eu-west and Singapore. The harness classifies every response (ok / http_err / stale / timeout) with an Algorand-scaled staleness gap (90 rounds, around 5 min). The cross-chain view lives on the parent @@ -33,16 +33,16 @@ methodology: - "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 last-round), http_err, stale (round more than 90 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=algorand. Provider coverage at launch: 3 no-key endpoints (AlgoNode, Nodely, Ankr)." + - "Chain scope: every query on this page is pinned to chain=algorand. Provider coverage at launch: 1 no-key endpoint (AlgoNode)." findings: - - "{{best_name}} currently leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h) across 3 measured providers." + - "{{best_name}} currently leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h)." faq: - q: "What is the fastest free Algorand RPC right now?" - a: "{{best_name}} currently leads at {{best_p50}} (Algorand algod /v2/status last-round p50 over the last 24h), measured against 3 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + a: "{{best_name}} currently leads at {{best_p50}} (Algorand algod /v2/status last-round p50 over the last 24h), measured against keyless providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." - q: "Which Algorand nodes work without an API key?" - a: "3 endpoints sustain continuous keyless probing at launch: AlgoNode community node, Nodely (formerly AlgoExplorer by Randlabs) and Ankr. Every listed endpoint was live-verified with a GET /v2/status returning a parsable last-round before inclusion." + a: "AlgoNode is the primary community-operated endpoint that sustains continuous keyless probing. Every listed endpoint was live-verified with a GET /v2/status returning a parsable last-round before inclusion." - q: "Does the fastest Algorand 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 Algorand RPC latency measured here, technically?" @@ -86,49 +86,3 @@ providers: - region: ap-southeast p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="algonode", chain="algorand", region="sgp"}) series: avg_over_time(rpc_latency_milliseconds{provider="algonode", chain="algorand", region="sgp"}[1h]) - - - slug: nodely - name: Nodely - tag: Nodely (formerly AlgoExplorer by Randlabs), professional Algorand infrastructure, free public tier - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to Nodely's Algorand endpoint." - queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nodely", chain="algorand"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nodely", chain="algorand"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nodely", chain="algorand"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="nodely", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="nodely", chain="algorand"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="nodely", chain="algorand"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand"}[1h])) - regions: - - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="us-east"}[1h]) - - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="eu-west"}[1h]) - - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="sgp"}[1h]) - - - slug: ankr - name: Ankr - tag: Multi-cloud RPC provider, 50+ chains, public tier with no API key required - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to Ankr's Algorand endpoint." - queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ankr", chain="algorand"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ankr", chain="algorand"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ankr", chain="algorand"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="ankr", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="ankr", chain="algorand"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="ankr", chain="algorand"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand"}[1h])) - regions: - - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand", region="us-east"}[1h]) - - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand", region="eu-west"}[1h]) - - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="algorand", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="algorand", region="sgp"}[1h]) diff --git a/benchmarks/aptos-rpc.yml b/benchmarks/aptos-rpc.yml index 88f17dba..3b201de7 100644 --- a/benchmarks/aptos-rpc.yml +++ b/benchmarks/aptos-rpc.yml @@ -4,7 +4,7 @@ slug: aptos-rpc number: "212" title: Fastest free Aptos RPC, live no-key endpoint latency seo_title: "Fastest free Aptos RPC 2026" -seo_description: "{{best_name}} leads free Aptos RPC at {{best_p50}} (REST ledger block_height p50, 24h). 4 no-key providers measured every 60s from 3 regions." +seo_description: "{{best_name}} leads free Aptos RPC at {{best_p50}} (REST ledger block_height p50, 24h). 2 no-key providers measured every 60s from 3 regions." subtitle: HTTP round-trip latency for the Aptos REST ledger endpoint (block_height) against every free, no-key public Aptos node, audited every 60 seconds from 3 regions. category: RPCs @@ -14,13 +14,13 @@ unit: ms higher_is_better: false seo_intro: | - Aptos is a Move-based L1 blockchain targeting over 100,000 TPS via Block-STM parallel execution, producing roughly one block per second with sub-second finality. Unlike EVM chains, Aptos exposes a REST API rather than JSON-RPC: GET /v1/ returns the current ledger block_height as a decimal string. Free public API endpoints are available without a key from Aptos Labs, PublicNode, Ankr and NodeReal. Every provider was live-verified with consecutive keyless GET /v1/ probes at launch. + Aptos is a Move-based L1 blockchain targeting over 100,000 TPS via Block-STM parallel execution, producing roughly one block per second with sub-second finality. Unlike EVM chains, Aptos exposes a REST API rather than JSON-RPC: GET /v1/ returns the current ledger block_height as a decimal string. Free public API endpoints are available without a key from Aptos Labs (two endpoints). Every provider was live-verified with consecutive keyless GET /v1/ probes at launch. abstract: | Per-chain member of the RPC latency cluster, extended to Aptos. We measure the round-trip latency of a single REST GET to /v1/ against every no-key public Aptos node that sustains continuous probing: - 4 providers at launch, every 60 seconds, from us-east, eu-west and + 2 providers at launch, every 60 seconds, from us-east, eu-west and Singapore. The harness classifies every response (ok / http_err / stale / timeout) with an Aptos-scaled staleness gap (300 blocks, around 5 min). The cross-chain view lives on the parent @@ -33,16 +33,16 @@ methodology: - "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_height), http_err, stale (block more than 300 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=aptos. Provider coverage at launch: 4 no-key endpoints (Aptos Labs, PublicNode, Ankr, NodeReal)." + - "Chain scope: every query on this page is pinned to chain=aptos. Provider coverage at launch: 2 no-key endpoints (Aptos Labs api, Aptos Labs fullnode)." findings: - - "{{best_name}} currently leads free Aptos RPC at {{best_p50}} (ledger block_height p50, 24h) across 4 measured providers." + - "{{best_name}} currently leads free Aptos RPC at {{best_p50}} (ledger block_height p50, 24h) across 2 measured providers." faq: - q: "What is the fastest free Aptos RPC right now?" - a: "{{best_name}} currently leads at {{best_p50}} (Aptos REST /v1/ block_height p50 over the last 24h), measured against 4 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + a: "{{best_name}} currently leads at {{best_p50}} (Aptos REST /v1/ block_height p50 over the last 24h), measured against 2 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." - q: "Which Aptos nodes work without an API key?" - a: "4 endpoints sustain continuous keyless probing at launch: Aptos Labs official node, PublicNode, Ankr and NodeReal. Every listed endpoint was live-verified with a GET /v1/ returning a parsable block_height before inclusion." + a: "2 endpoints sustain continuous keyless probing at launch: the Aptos Labs official API node and the Aptos Labs fullnode endpoint. Every listed endpoint was live-verified with a GET /v1/ returning a parsable block_height before inclusion." - q: "Does the fastest Aptos 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 Aptos RPC latency measured here, technically?" @@ -87,71 +87,25 @@ providers: p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptoslabs", chain="aptos", region="sgp"}) series: avg_over_time(rpc_latency_milliseconds{provider="aptoslabs", chain="aptos", region="sgp"}[1h]) - - slug: publicnode - name: PublicNode - tag: High-uptime community RPC provider, 25+ chains, no key required, operated by Allnodes - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to PublicNode's Aptos endpoint." + - slug: aptos-fullnode + name: Aptos Labs (Fullnode) + tag: Aptos Labs fullnode endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to the Aptos Labs fullnode endpoint." queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="publicnode", chain="aptos"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="publicnode", chain="aptos"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="publicnode", chain="aptos"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="publicnode", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="publicnode", chain="aptos"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="publicnode", chain="aptos"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos"}[1h])) + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptos-fullnode", chain="aptos"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="aptos-fullnode", chain="aptos"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="aptos-fullnode", chain="aptos"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="aptos-fullnode", chain="aptos"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="aptos-fullnode", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="aptos-fullnode", chain="aptos"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="aptos-fullnode", chain="aptos"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="aptos-fullnode", chain="aptos"}[1h])) regions: - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos", region="us-east"}[1h]) + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptos-fullnode", chain="aptos", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="aptos-fullnode", chain="aptos", region="us-east"}[1h]) - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos", region="eu-west"}[1h]) + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptos-fullnode", chain="aptos", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="aptos-fullnode", chain="aptos", region="eu-west"}[1h]) - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="aptos", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="aptos", region="sgp"}[1h]) - - - slug: ankr - name: Ankr - tag: Multi-cloud RPC provider, 50+ chains, public tier with no API key required - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to Ankr's Aptos endpoint." - queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ankr", chain="aptos"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ankr", chain="aptos"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ankr", chain="aptos"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="ankr", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="ankr", chain="aptos"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="ankr", chain="aptos"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos"}[1h])) - regions: - - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos", region="us-east"}[1h]) - - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos", region="eu-west"}[1h]) - - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ankr", chain="aptos", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="ankr", chain="aptos", region="sgp"}[1h]) - - - slug: nodereal - name: NodeReal - tag: Enterprise-grade multi-chain infrastructure, public Aptos endpoint, no key required - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v1/ sent every 60s from 3 regions to NodeReal's Aptos endpoint." - queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nodereal", chain="aptos"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nodereal", chain="aptos"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nodereal", chain="aptos"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="nodereal", chain="aptos"}) / sum(ocb:rpc_call:rate_24h{provider="nodereal", chain="aptos"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="nodereal", chain="aptos"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos"}[1h])) - regions: - - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos", region="us-east"}[1h]) - - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos", region="eu-west"}[1h]) - - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodereal", chain="aptos", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nodereal", chain="aptos", region="sgp"}[1h]) + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="aptos-fullnode", chain="aptos", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="aptos-fullnode", chain="aptos", region="sgp"}[1h]) diff --git a/benchmarks/gram-rpc.yml b/benchmarks/gram-rpc.yml index 582ac1c5..92fa7c28 100644 --- a/benchmarks/gram-rpc.yml +++ b/benchmarks/gram-rpc.yml @@ -4,7 +4,7 @@ slug: gram-rpc number: "215" title: Fastest free Gram RPC, live no-key endpoint latency seo_title: "Fastest free Gram (TON) RPC 2026" -seo_description: "{{best_name}} leads free Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h). 3 providers measured every 60s from 3 regions." +seo_description: "{{best_name}} leads free Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h). Measured every 60s from 3 regions." subtitle: HTTP round-trip latency for getMasterchainInfo against every available public Gram (TON) node, audited every 60 seconds from 3 regions. category: RPCs @@ -14,13 +14,13 @@ unit: ms higher_is_better: false seo_intro: | - Gram (formerly TON/Toncoin) is a high-throughput L1 blockchain using the BAG (Byzantine Agreement for Gram) consensus protocol and a multi-workchain architecture anchored by a masterchain. The masterchain seqno advances roughly every 5 seconds with deterministic finality. Public JSON-RPC endpoints are available from TON Center (keyless at 1 req/s), dRPC and NOWNodes. Every provider was live-verified with consecutive getMasterchainInfo probes at launch. + Gram (formerly TON/Toncoin) is a high-throughput L1 blockchain using the BAG (Byzantine Agreement for Gram) consensus protocol and a multi-workchain architecture anchored by a masterchain. The masterchain seqno advances roughly every 5 seconds with deterministic finality. TON Center provides a public JSON-RPC endpoint keyless at 1 req/s (matching our 60-second probe cadence exactly). Every provider was live-verified with consecutive getMasterchainInfo probes at launch. abstract: | Per-chain member of the RPC latency cluster, extended to Gram. We measure the round-trip latency of a single JSON-RPC call (getMasterchainInfo) against every available public Gram node that - sustains continuous probing: 3 providers at launch, every 60 seconds, + sustains continuous probing: 1 provider 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 Gram-scaled staleness gap (60 seqnos, around 5 min). The cross-chain @@ -33,16 +33,16 @@ methodology: - "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 result.last.seqno), http_err, jsonrpc_err, stale (seqno more than 60 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=gram. Provider coverage at launch: 3 endpoints (TON Center, dRPC, NOWNodes)." + - "Chain scope: every query on this page is pinned to chain=gram. Provider coverage at launch: 1 endpoint (TON Center, keyless at 1 req/s)." findings: - - "{{best_name}} currently leads Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h) across 3 measured providers." + - "{{best_name}} currently leads Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h)." faq: - q: "What is the fastest free Gram (TON) RPC right now?" - a: "{{best_name}} currently leads at {{best_p50}} (getMasterchainInfo seqno 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." + a: "{{best_name}} currently leads at {{best_p50}} (getMasterchainInfo seqno p50 over the last 24h), measured against keyless providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." - q: "Which Gram RPC endpoints work without an API key?" - a: "TON Center provides keyless access at up to 1 request per second, which fits our 60-second probe cadence exactly. dRPC and NOWNodes may require a key for sustained access. Every listed endpoint was live-verified with a getMasterchainInfo call returning a parsable seqno before inclusion." + a: "TON Center provides keyless access at up to 1 request per second, which fits our 60-second probe cadence exactly. Every listed endpoint was live-verified with a getMasterchainInfo call returning a parsable seqno before inclusion." - q: "Does the fastest Gram 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 Gram RPC latency measured here, technically?" @@ -86,49 +86,3 @@ providers: - region: ap-southeast p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="toncenter", chain="gram", region="sgp"}) series: avg_over_time(rpc_latency_milliseconds{provider="toncenter", chain="gram", region="sgp"}[1h]) - - - slug: drpc - name: dRPC - tag: Decentralized RPC mesh, consensus-checked responses, 29+ chains, 210M CU/mo free tier - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to dRPC's Gram endpoint." - queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="gram"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="gram"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="gram"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="gram"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="gram"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram"}[1h])) - regions: - - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram", region="us-east"}[1h]) - - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram", region="eu-west"}[1h]) - - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="gram", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="gram", region="sgp"}[1h]) - - - slug: nownodes - name: NOWNodes - tag: Multi-chain node provider with Gram (TON) support, API key required for sustained access - formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to NOWNodes' Gram endpoint." - queries: - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram"}) - p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nownodes", chain="gram"}) - p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nownodes", chain="gram"}) - mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nownodes", chain="gram"}) - success: sum(ocb:rpc_call:ok_rate_24h{provider="nownodes", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="nownodes", chain="gram"}) - sample_size: sum(ocb:rpc_call:increase_24h{provider="nownodes", chain="gram"}) - series: avg(avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram"}[1h])) - regions: - - region: us-east - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram", region="us-east"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram", region="us-east"}[1h]) - - region: eu-west - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram", region="eu-west"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram", region="eu-west"}[1h]) - - region: ap-southeast - p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nownodes", chain="gram", region="sgp"}) - series: avg_over_time(rpc_latency_milliseconds{provider="nownodes", chain="gram", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index 91e3193a..4825878a 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -1507,16 +1507,14 @@ func chains() []Chain { {Slug: "onfinality", Name: "OnFinality", URL: envDefault("RPC_URL_SUI_ONFINALITY", "https://sui.api.onfinality.io/public")}, }, }, - // Aptos — Move VM, REST GET /v1/ block_height probe, ~1 block/s. 3 keyless providers. + // Aptos — Move VM, REST GET /v1/ block_height probe, ~1 block/s. 2 verified-free providers. { Slug: "aptos", Name: "Aptos", Kind: "aptos", Providers: []Provider{ {Slug: "aptoslabs", Name: "Aptos Labs", URL: envDefault("RPC_URL_APTOS_APTOSLABS", "https://api.mainnet.aptoslabs.com/v1/")}, - {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_APTOS_PUBLICNODE", "https://aptos-mainnet.publicnode.com/v1/")}, - {Slug: "ankr", Name: "Ankr", URL: envDefault("RPC_URL_APTOS_ANKR", "https://rpc.ankr.com/http/aptos/v1")}, - {Slug: "nodereal", Name: "NodeReal", URL: envDefault("RPC_URL_APTOS_NODEREAL", "https://aptos-mainnet.nodereal.io/v1/")}, + {Slug: "aptos-fullnode", Name: "Aptos Labs (Fullnode)", URL: envDefault("RPC_URL_APTOS_FULLNODE", "https://fullnode.mainnet.aptoslabs.com/v1/")}, }, }, // XRP Ledger — ledger_current JSON-RPC probe, ~3-4 s ledger close. 3 keyless providers. @@ -1530,26 +1528,22 @@ func chains() []Chain { {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_XRP_PUBLICNODE", "https://xrp-rpc.publicnode.com")}, }, }, - // Algorand — REST GET /v2/status last-round probe, ~3.5 s per round. 2 keyless providers. + // Algorand — REST GET /v2/status last-round probe, ~3.5 s per round. 1 verified-free provider. { Slug: "algorand", Name: "Algorand", Kind: "algorand", Providers: []Provider{ {Slug: "algonode", Name: "AlgoNode", URL: envDefault("RPC_URL_ALGORAND_ALGONODE", "https://mainnet-api.algonode.cloud")}, - {Slug: "nodely", Name: "Nodely", URL: envDefault("RPC_URL_ALGORAND_NODELY", "https://mainnet-api.4160.nodely.io")}, - {Slug: "ankr", Name: "Ankr", URL: envDefault("RPC_URL_ALGORAND_ANKR", "https://rpc.ankr.com/algorand")}, }, }, - // Gram — TON masterchain, getMasterchainInfo JSON-RPC, ~5 s seqno. 3 providers (toncenter keyless). + // Gram — TON masterchain, getMasterchainInfo JSON-RPC, ~5 s seqno. 1 verified-free provider. { Slug: "gram", Name: "Gram", Kind: "gram", Providers: []Provider{ {Slug: "toncenter", Name: "TON Center", URL: envDefault("RPC_URL_GRAM_TONCENTER", "https://toncenter.com/api/v2/jsonRPC")}, - {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_GRAM_DRPC", "https://ton.drpc.org")}, - {Slug: "nownodes", Name: "NOWNodes", URL: envDefault("RPC_URL_GRAM_NOWNODES", "https://ton.nownodes.io/jsonRPC")}, }, }, } diff --git a/src/data/provider-registry.ts b/src/data/provider-registry.ts index 7180dea8..d6065726 100644 --- a/src/data/provider-registry.ts +++ b/src/data/provider-registry.ts @@ -2218,6 +2218,13 @@ export const PROVIDER_REGISTRY: Record = { "Official Aptos Labs public mainnet node at api.mainnet.aptoslabs.com. No API key required; the canonical reference endpoint maintained by the Aptos Foundation and Aptos Labs.", twitter: "@AptosLabs", }, + "aptos-fullnode": { + url: "https://aptoslabs.com", + description: + "Aptos Labs fullnode endpoint at fullnode.mainnet.aptoslabs.com. No API key required; a second publicly accessible REST endpoint maintained by Aptos Labs alongside the primary API node.", + twitter: "@AptosLabs", + parent: "aptoslabs", + }, nodereal: { url: "https://nodereal.io", description: diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index c78f3136..7710ad23 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -170,6 +170,7 @@ const RAW: Record = { suiet: "/logos/suiet.svg", // ─── Aptos providers (bench 212) ─── aptoslabs: "/logos/aptoslabs.svg", + "aptos-fullnode": "/logos/aptoslabs.svg", nodereal: "/logos/nodereal.svg", // ─── XRP providers (bench 213) ─── ripple: "/logos/ripple.svg", From c8fe775506769e63dc724644930516db160509ee Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 20:58:02 +0200 Subject: [PATCH 4/8] fix(logos): use real aptos.svg for aptoslabs and aptos-fullnode providers --- src/lib/logo-manifest.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index 7710ad23..c2f387a6 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -169,8 +169,8 @@ const RAW: Record = { blockvision: "/logos/blockvision.svg", suiet: "/logos/suiet.svg", // ─── Aptos providers (bench 212) ─── - aptoslabs: "/logos/aptoslabs.svg", - "aptos-fullnode": "/logos/aptoslabs.svg", + aptoslabs: "/logos/aptos.svg", + "aptos-fullnode": "/logos/aptos.svg", nodereal: "/logos/nodereal.svg", // ─── XRP providers (bench 213) ─── ripple: "/logos/ripple.svg", From 292404369fba575df27b32effc5eb0563f8a1a32 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 21:11:42 +0200 Subject: [PATCH 5/8] fix(logos): use real logos for toncenter/algonode/ripple/xrpl-labs providers --- public/logos/algorand.svg | 4 ++-- src/lib/logo-manifest.ts | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/public/logos/algorand.svg b/public/logos/algorand.svg index 584ee79f..304bf856 100644 --- a/public/logos/algorand.svg +++ b/public/logos/algorand.svg @@ -1,4 +1,4 @@ - - AL + + diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index c2f387a6..116adbf3 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -173,13 +173,13 @@ const RAW: Record = { "aptos-fullnode": "/logos/aptos.svg", nodereal: "/logos/nodereal.svg", // ─── XRP providers (bench 213) ─── - ripple: "/logos/ripple.svg", - "xrpl-labs": "/logos/xrpl-labs.svg", + ripple: "/logos/xrp.jpg", + "xrpl-labs": "/logos/xrp.jpg", // ─── Algorand providers (bench 214) ─── - algonode: "/logos/algonode.svg", + algonode: "/logos/algorand.svg", nodely: "/logos/nodely.svg", // ─── Gram/TON providers (bench 215) ─── - toncenter: "/logos/toncenter.svg", + toncenter: "/logos/ton.svg", nownodes: "/logos/nownodes.svg", infura: "/logos/infura.png", ankr: "/logos/ankr.png", From c7049fa97827970633b5535ea2653815403c7b26 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 21:21:24 +0200 Subject: [PATCH 6/8] feat(rpc): add onfinality/tatum/uniblock for gram, nodely/tatum for algorand --- benchmarks/algorand-rpc.yml | 60 ++++++++++++-- benchmarks/gram-rpc.yml | 83 +++++++++++++++++-- .../rpc-capabilities/cmd/script/config.go | 9 +- public/logos/tatum.svg | 4 + public/logos/uniblock.svg | 4 + src/data/provider-registry.ts | 12 +++ src/lib/logo-manifest.ts | 2 + 7 files changed, 158 insertions(+), 16 deletions(-) create mode 100644 public/logos/tatum.svg create mode 100644 public/logos/uniblock.svg diff --git a/benchmarks/algorand-rpc.yml b/benchmarks/algorand-rpc.yml index d99c7d26..45bf3431 100644 --- a/benchmarks/algorand-rpc.yml +++ b/benchmarks/algorand-rpc.yml @@ -4,7 +4,7 @@ slug: algorand-rpc number: "214" title: Fastest free Algorand RPC, live no-key endpoint latency seo_title: "Fastest free Algorand RPC 2026" -seo_description: "{{best_name}} leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h). Measured every 60s from 3 regions." +seo_description: "{{best_name}} leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h). 3 no-key providers measured every 60s from 3 regions." subtitle: HTTP round-trip latency for the Algorand algod status endpoint (last-round) against every free, no-key public Algorand node, audited every 60 seconds from 3 regions. category: RPCs @@ -14,13 +14,13 @@ unit: ms higher_is_better: false seo_intro: | - Algorand is an L1 blockchain using a Pure Proof-of-Stake consensus (BA* Byzantine Agreement) that commits one round every roughly 3.5 seconds with immediate finality and no forks. Algorand nodes expose a REST algod API rather than JSON-RPC: GET /v2/status returns the current last-round (equivalent to block height). The AlgoNode community endpoint is available free without a key. Every provider was live-verified with consecutive keyless GET /v2/status probes at launch. + Algorand is an L1 blockchain using a Pure Proof-of-Stake consensus (BA* Byzantine Agreement) that commits one round every roughly 3.5 seconds with immediate finality and no forks. Algorand nodes expose a REST algod API rather than JSON-RPC: GET /v2/status returns the current last-round (equivalent to block height). Free public API endpoints are available without a key from AlgoNode, Nodely and Tatum. Every provider was live-verified with consecutive keyless GET /v2/status probes at launch. abstract: | Per-chain member of the RPC latency cluster, extended to Algorand. We measure the round-trip latency of a single REST GET to /v2/status against every no-key public Algorand algod node that sustains - continuous probing: 1 provider at launch, every 60 seconds, from + continuous probing: 3 providers at launch, every 60 seconds, from us-east, eu-west and Singapore. The harness classifies every response (ok / http_err / stale / timeout) with an Algorand-scaled staleness gap (90 rounds, around 5 min). The cross-chain view lives on the parent @@ -33,16 +33,16 @@ methodology: - "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 last-round), http_err, stale (round more than 90 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=algorand. Provider coverage at launch: 1 no-key endpoint (AlgoNode)." + - "Chain scope: every query on this page is pinned to chain=algorand. Provider coverage at launch: 3 no-key endpoints (AlgoNode, Nodely, Tatum)." findings: - - "{{best_name}} currently leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h)." + - "{{best_name}} currently leads free Algorand RPC at {{best_p50}} (algod /v2/status last-round p50, 24h) across 3 measured providers." faq: - q: "What is the fastest free Algorand RPC right now?" - a: "{{best_name}} currently leads at {{best_p50}} (Algorand algod /v2/status last-round p50 over the last 24h), measured against keyless providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + a: "{{best_name}} currently leads at {{best_p50}} (Algorand algod /v2/status last-round p50 over the last 24h), measured against 3 no-key providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." - q: "Which Algorand nodes work without an API key?" - a: "AlgoNode is the primary community-operated endpoint that sustains continuous keyless probing. Every listed endpoint was live-verified with a GET /v2/status returning a parsable last-round before inclusion." + a: "3 endpoints sustain continuous keyless probing at launch: AlgoNode community node, Nodely (mainnet-api.4160.nodely.dev) and Tatum gateway. Every listed endpoint was live-verified with a GET /v2/status returning a parsable last-round before inclusion." - q: "Does the fastest Algorand 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 Algorand RPC latency measured here, technically?" @@ -86,3 +86,49 @@ providers: - region: ap-southeast p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="algonode", chain="algorand", region="sgp"}) series: avg_over_time(rpc_latency_milliseconds{provider="algonode", chain="algorand", region="sgp"}[1h]) + + - slug: nodely + name: Nodely + tag: Nodely free Algorand algod node (mainnet-api.4160.nodely.dev), no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to Nodely's Algorand endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nodely", chain="algorand"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nodely", chain="algorand"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nodely", chain="algorand"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="nodely", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="nodely", chain="algorand"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="nodely", chain="algorand"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nodely", chain="algorand", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nodely", chain="algorand", region="sgp"}[1h]) + + - slug: tatum + name: Tatum + tag: Multi-chain RPC gateway with Algorand algod support, public endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a REST GET to /v2/status sent every 60s from 3 regions to Tatum's Algorand algod gateway." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="algorand"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="tatum", chain="algorand"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="tatum", chain="algorand"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="tatum", chain="algorand"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="tatum", chain="algorand"}) / sum(ocb:rpc_call:rate_24h{provider="tatum", chain="algorand"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="tatum", chain="algorand"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="algorand"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="algorand", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="algorand", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="algorand", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="algorand", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="algorand", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="algorand", region="sgp"}[1h]) diff --git a/benchmarks/gram-rpc.yml b/benchmarks/gram-rpc.yml index 92fa7c28..023618b9 100644 --- a/benchmarks/gram-rpc.yml +++ b/benchmarks/gram-rpc.yml @@ -4,7 +4,7 @@ slug: gram-rpc number: "215" title: Fastest free Gram RPC, live no-key endpoint latency seo_title: "Fastest free Gram (TON) RPC 2026" -seo_description: "{{best_name}} leads free Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h). Measured every 60s from 3 regions." +seo_description: "{{best_name}} leads free Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h). 4 providers measured every 60s from 3 regions." subtitle: HTTP round-trip latency for getMasterchainInfo against every available public Gram (TON) node, audited every 60 seconds from 3 regions. category: RPCs @@ -14,13 +14,13 @@ unit: ms higher_is_better: false seo_intro: | - Gram (formerly TON/Toncoin) is a high-throughput L1 blockchain using the BAG (Byzantine Agreement for Gram) consensus protocol and a multi-workchain architecture anchored by a masterchain. The masterchain seqno advances roughly every 5 seconds with deterministic finality. TON Center provides a public JSON-RPC endpoint keyless at 1 req/s (matching our 60-second probe cadence exactly). Every provider was live-verified with consecutive getMasterchainInfo probes at launch. + Gram (formerly TON/Toncoin) is a high-throughput L1 blockchain using the BAG (Byzantine Agreement for Gram) consensus protocol and a multi-workchain architecture anchored by a masterchain. The masterchain seqno advances roughly every 5 seconds with deterministic finality. Public JSON-RPC endpoints are available from TON Center, OnFinality, Tatum and Uniblock. Every provider was live-verified with consecutive getMasterchainInfo probes at launch. abstract: | Per-chain member of the RPC latency cluster, extended to Gram. We measure the round-trip latency of a single JSON-RPC call (getMasterchainInfo) against every available public Gram node that - sustains continuous probing: 1 provider at launch, every 60 seconds, + sustains continuous probing: 4 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 Gram-scaled staleness gap (60 seqnos, around 5 min). The cross-chain @@ -33,16 +33,16 @@ methodology: - "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 result.last.seqno), http_err, jsonrpc_err, stale (seqno more than 60 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=gram. Provider coverage at launch: 1 endpoint (TON Center, keyless at 1 req/s)." + - "Chain scope: every query on this page is pinned to chain=gram. Provider coverage at launch: 4 endpoints (TON Center, OnFinality, Tatum, Uniblock)." findings: - - "{{best_name}} currently leads Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h)." + - "{{best_name}} currently leads Gram RPC at {{best_p50}} (getMasterchainInfo seqno p50, 24h) across 4 measured providers." faq: - q: "What is the fastest free Gram (TON) RPC right now?" - a: "{{best_name}} currently leads at {{best_p50}} (getMasterchainInfo seqno p50 over the last 24h), measured against keyless providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + a: "{{best_name}} currently leads at {{best_p50}} (getMasterchainInfo seqno p50 over the last 24h), measured against 4 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." - q: "Which Gram RPC endpoints work without an API key?" - a: "TON Center provides keyless access at up to 1 request per second, which fits our 60-second probe cadence exactly. Every listed endpoint was live-verified with a getMasterchainInfo call returning a parsable seqno before inclusion." + a: "4 endpoints sustain continuous keyless probing at launch: TON Center (1 req/s), OnFinality, Tatum and Uniblock. Every listed endpoint was live-verified with a getMasterchainInfo call returning a parsable seqno before inclusion." - q: "Does the fastest Gram 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 Gram RPC latency measured here, technically?" @@ -86,3 +86,72 @@ providers: - region: ap-southeast p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="toncenter", chain="gram", region="sgp"}) series: avg_over_time(rpc_latency_milliseconds{provider="toncenter", chain="gram", region="sgp"}[1h]) + + - slug: onfinality + name: OnFinality + tag: Multi-chain RPC provider with TON support, public endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to OnFinality's TON endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="gram"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="onfinality", chain="gram"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="onfinality", chain="gram"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="onfinality", chain="gram"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="onfinality", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="onfinality", chain="gram"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="onfinality", chain="gram"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="gram"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="gram", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="gram", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="gram", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="gram", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onfinality", chain="gram", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onfinality", chain="gram", region="sgp"}[1h]) + + - slug: tatum + name: Tatum + tag: Multi-chain RPC gateway with TON support, public endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to Tatum's TON gateway." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="gram"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="tatum", chain="gram"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="tatum", chain="gram"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="tatum", chain="gram"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="tatum", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="tatum", chain="gram"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="tatum", chain="gram"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="gram"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="gram", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="gram", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="gram", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="gram", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="gram", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="gram", region="sgp"}[1h]) + + - slug: uniblock + name: Uniblock + tag: Multi-chain RPC aggregator with TON support, public endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getMasterchainInfo POST sent every 60s from 3 regions to Uniblock's TON endpoint." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="uniblock", chain="gram"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="uniblock", chain="gram"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="uniblock", chain="gram"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="uniblock", chain="gram"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="uniblock", chain="gram"}) / sum(ocb:rpc_call:rate_24h{provider="uniblock", chain="gram"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="uniblock", chain="gram"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="uniblock", chain="gram"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="uniblock", chain="gram", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="uniblock", chain="gram", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="uniblock", chain="gram", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="uniblock", chain="gram", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="uniblock", chain="gram", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="uniblock", chain="gram", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index 4825878a..01ab39f6 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -1528,22 +1528,27 @@ func chains() []Chain { {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_XRP_PUBLICNODE", "https://xrp-rpc.publicnode.com")}, }, }, - // Algorand — REST GET /v2/status last-round probe, ~3.5 s per round. 1 verified-free provider. + // Algorand — REST GET /v2/status last-round probe, ~3.5 s per round. { Slug: "algorand", Name: "Algorand", Kind: "algorand", Providers: []Provider{ {Slug: "algonode", Name: "AlgoNode", URL: envDefault("RPC_URL_ALGORAND_ALGONODE", "https://mainnet-api.algonode.cloud")}, + {Slug: "nodely", Name: "Nodely", URL: envDefault("RPC_URL_ALGORAND_NODELY", "https://mainnet-api.4160.nodely.dev")}, + {Slug: "tatum", Name: "Tatum", URL: envDefault("RPC_URL_ALGORAND_TATUM", "https://algorand-mainnet-algod.gateway.tatum.io")}, }, }, - // Gram — TON masterchain, getMasterchainInfo JSON-RPC, ~5 s seqno. 1 verified-free provider. + // Gram — TON masterchain, getMasterchainInfo JSON-RPC, ~5 s seqno. { Slug: "gram", Name: "Gram", Kind: "gram", Providers: []Provider{ {Slug: "toncenter", Name: "TON Center", URL: envDefault("RPC_URL_GRAM_TONCENTER", "https://toncenter.com/api/v2/jsonRPC")}, + {Slug: "onfinality", Name: "OnFinality", URL: envDefault("RPC_URL_GRAM_ONFINALITY", "https://ton.api.onfinality.io/public/jsonRPC")}, + {Slug: "tatum", Name: "Tatum", URL: envDefault("RPC_URL_GRAM_TATUM", "https://ton-mainnet.gateway.tatum.io/jsonRPC")}, + {Slug: "uniblock", Name: "Uniblock", URL: envDefault("RPC_URL_GRAM_UNIBLOCK", "https://api.uniblock.dev/uni/v1/json-rpc?chainId=toncoin")}, }, }, } diff --git a/public/logos/tatum.svg b/public/logos/tatum.svg new file mode 100644 index 00000000..a1acf419 --- /dev/null +++ b/public/logos/tatum.svg @@ -0,0 +1,4 @@ + + + TAT + diff --git a/public/logos/uniblock.svg b/public/logos/uniblock.svg new file mode 100644 index 00000000..deeaa515 --- /dev/null +++ b/public/logos/uniblock.svg @@ -0,0 +1,4 @@ + + + UNI + diff --git a/src/data/provider-registry.ts b/src/data/provider-registry.ts index d6065726..cea00546 100644 --- a/src/data/provider-registry.ts +++ b/src/data/provider-registry.ts @@ -2273,6 +2273,18 @@ export const PROVIDER_REGISTRY: Record = { "NOWNodes is a multi-chain node provider covering Gram (TON), Bitcoin, Ethereum and 50+ other chains. Offers API-key-based access with a free trial tier.", twitter: "@NOWNodes_io", }, + tatum: { + url: "https://tatum.io", + description: + "Tatum is a multi-chain RPC gateway supporting TON, Algorand and 30+ blockchains. Provides a public no-key endpoint for basic queries.", + twitter: "@TatumIO", + }, + uniblock: { + url: "https://uniblock.dev", + description: + "Uniblock is a multi-chain RPC aggregator providing unified access to TON and other blockchains via a public JSON-RPC endpoint, no API key required.", + twitter: "@UniblockDev", + }, }; /** diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index 116adbf3..8e995e39 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -181,6 +181,8 @@ const RAW: Record = { // ─── Gram/TON providers (bench 215) ─── toncenter: "/logos/ton.svg", nownodes: "/logos/nownodes.svg", + tatum: "/logos/tatum.svg", + uniblock: "/logos/uniblock.svg", infura: "/logos/infura.png", ankr: "/logos/ankr.png", chainstack: "/logos/chainstack.svg", From 5090a71dc3a6dc9ad4d56594bba93abf47976746 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 21:45:46 +0200 Subject: [PATCH 7/8] fix(logos): real SVGs for tatum/uniblock, PNG for nodely, correct brand colors --- public/logos/nodely.png | Bin 0 -> 1477 bytes public/logos/tatum.svg | 10 +++++++--- public/logos/uniblock.svg | 5 +---- src/data/provider-registry.ts | 2 +- src/lib/brand.ts | 7 ++++++- src/lib/logo-manifest.ts | 2 +- 6 files changed, 16 insertions(+), 10 deletions(-) create mode 100644 public/logos/nodely.png diff --git a/public/logos/nodely.png b/public/logos/nodely.png new file mode 100644 index 0000000000000000000000000000000000000000..91a9060fdc1e18a46f1e932dd477a376d2a41c4d GIT binary patch literal 1477 zcmah|X;4#F7`+-53PzFVP!G$2f22$saKyjcL$6dKM)EX6c2lI`yeK!zm%*|`ABVx{b1 z0MaM`jD!QgC)&|Ezz5F?-#*M zMR0F9{FfSfbro(t2{#wPFDv0mCA6Q1IM|_%4k*JO4faB2)zDxCoF0a-9MQUba(Xxd zAt*{g5egc}Mt?gAKd*qPRMd`+D)Y$c5eSSu+Moe!bnptiCk#PtP&->xb(kE;LB+cf zE*rI>qT(=w>xriAMxIr`fgI$R<>?kGx_yd{2|W?V+g)#X@lwMz z#>uT_K>*;KIBu+f^gi8_5UvT!cxm{$U!!XI%Pk3t4_2{Xk)r%s7#^>~Ybz3;Wp_ z0BULC&UD_+njE!B-HE9HRy4Gw7UwUAQ=z_y5^%j}%rA&RT3r@$% zUS`5yxtOkX$y{a5DDJj!XnYFqpyvg)y31lZ%T}JMPkMji&dm7r*&9h?2HxIVAB0sQ zR;jvKVN{%^rcT<@5&FMz^ha@+Kt5whV$NtujLL-*3nMEulC-YNE;UD5Kk*LG(DseF`pH|7<; zzMxs|&AjEg={;#{&mXr-62*m`LyWh%wF0|f?M&>1@SSwxW>;N~kpH)R*!F(&Vu_Y> zyXwu(DPbSWL)j45Cwx~PxT{Efd^K5}oS+<)cAKA>(JuJtOYDNXQe5vD(FA(+UA3d! zw0Ff@OxuTrrlh%ZC0!||jhf!eF$v1~^Jsf?jwZ)RN~qb;dM-Y?5hwc6SrXf;&>Oa> zOz6wHhg0%8vZOj3mLCqw`2T=uJ={#Q5%c}_eKa?tDcO5=kBx;~E$NcgKU~3>(-X%I zeNDJr-S^V}QLl=tkll|}mkk^`#+VBt+&j`4ePMqNt@i9H4<-ASt|+u3#T9NC+Pa{t zk8=EGuXD9;UdP63@h@DDMyr__q|IkGUle!bnw8=EGXE?zaw9}t#a`GW9#ebxB_uBs-kho5{h(XvA|3O%lDDXr{T z9;@c3K47W@u1}mG?ZskRT2>FzC6jEUP7g7v3NAENY-6%Y$37L33ar$R!*xiu!W|x5(O}W$c$-$UQ zE+WCl)0P|h*A~>ycc1f^+cH@qXBW|qPv-ggo_(RdKX35w)s-Gt)|d0ymNNyz&fi*d zJu0sqvBo~vMv;54C@Mn4V??I#FalHxl}@Hm$rRfF8yg0d%Aisp3WY(TfXVcj&kXU2 zQG#g6e;bmo{L+sZc4Pzui~J+@5R+08qXj}9Q6x#?5d}%2NC47H2gjG|CkI(swfeTT zb6)xb9LW%gG$fD+UPZ<@0?{p--WY`=DFTRXk01Ts)ZVndNv|!NE&UDwBWsOB - - TAT + + + + + + + diff --git a/public/logos/uniblock.svg b/public/logos/uniblock.svg index deeaa515..e978235e 100644 --- a/public/logos/uniblock.svg +++ b/public/logos/uniblock.svg @@ -1,4 +1 @@ - - - UNI - + \ No newline at end of file diff --git a/src/data/provider-registry.ts b/src/data/provider-registry.ts index cea00546..2b93f3c6 100644 --- a/src/data/provider-registry.ts +++ b/src/data/provider-registry.ts @@ -2256,7 +2256,7 @@ export const PROVIDER_REGISTRY: Record = { nodely: { url: "https://nodely.io", description: - "Nodely (formerly AlgoExplorer by Randlabs) is a professional Algorand infrastructure provider offering a free public algod API tier at mainnet-api.4160.nodely.io with no API key required.", + "Nodely (formerly AlgoExplorer by Randlabs) is a professional Algorand infrastructure provider offering a free public algod API tier at mainnet-api.4160.nodely.dev with no API key required.", twitter: "@nodely_io", }, diff --git a/src/lib/brand.ts b/src/lib/brand.ts index 4a85ead7..58aa3de4 100644 --- a/src/lib/brand.ts +++ b/src/lib/brand.ts @@ -100,7 +100,12 @@ const BRANDS: Record = { // ─── Non-EVM L1s (benches 211-214) ─── aptos: { color: "#00C4FF" }, // aptos cyan (brand kit) - algorand: { color: "#00BCD4" }, // algorand teal + algorand: { color: "#000000" }, // algorand black (official brand) + + // ─── New RPC providers (benches 214-215) ─── + tatum: { color: "#4F37FD" }, // tatum purple + uniblock: { color: "#1FB6FF" }, // uniblock cyan + nodely: { color: "#F9B72B" }, // nodely amber // ─── Stellar ecosystem providers (bench № 210) ─── gateway: { color: "#00C2A8" }, // gateway.fm teal diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index 8e995e39..dbdad5ad 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -177,7 +177,7 @@ const RAW: Record = { "xrpl-labs": "/logos/xrp.jpg", // ─── Algorand providers (bench 214) ─── algonode: "/logos/algorand.svg", - nodely: "/logos/nodely.svg", + nodely: "/logos/nodely.png", // ─── Gram/TON providers (bench 215) ─── toncenter: "/logos/ton.svg", nownodes: "/logos/nownodes.svg", From 59bf7d70555198e6a14d4ab1739ed72c0fc97dd8 Mon Sep 17 00:00:00 2001 From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com> Date: Tue, 18 Aug 2026 22:43:17 +0200 Subject: [PATCH 8/8] feat(rpc): add 6 new chains (NEAR, Flow, Hedera, CKB, MultiversX, NEO N3) benches 216-221 --- benchmarks/ckb-rpc.yml | 112 +++++++ benchmarks/flow-rpc.yml | 112 +++++++ benchmarks/hedera-rpc.yml | 112 +++++++ benchmarks/multiversx-rpc.yml | 112 +++++++ benchmarks/near-rpc.yml | 157 +++++++++ benchmarks/neo-rpc.yml | 135 ++++++++ .../rpc-capabilities/cmd/script/config.go | 63 ++++ .../rpc-capabilities/cmd/script/probe.go | 313 +++++++++++++++++- public/logos/ckb.png | Bin 0 -> 1535 bytes public/logos/flow.png | Bin 0 -> 15191 bytes public/logos/flow.svg | 6 + public/logos/multiversx.png | Bin 0 -> 9024 bytes public/logos/near.jpg | Bin 0 -> 5516 bytes public/logos/neo.png | Bin 0 -> 2912 bytes src/data/provider-registry.ts | 79 +++++ src/lib/brand.ts | 22 ++ src/lib/chains.ts | 54 +++ src/lib/logo-manifest.ts | 26 ++ 18 files changed, 1302 insertions(+), 1 deletion(-) create mode 100644 benchmarks/ckb-rpc.yml create mode 100644 benchmarks/flow-rpc.yml create mode 100644 benchmarks/hedera-rpc.yml create mode 100644 benchmarks/multiversx-rpc.yml create mode 100644 benchmarks/near-rpc.yml create mode 100644 benchmarks/neo-rpc.yml create mode 100644 public/logos/ckb.png create mode 100644 public/logos/flow.png create mode 100644 public/logos/flow.svg create mode 100644 public/logos/multiversx.png create mode 100644 public/logos/near.jpg create mode 100644 public/logos/neo.png diff --git a/benchmarks/ckb-rpc.yml b/benchmarks/ckb-rpc.yml new file mode 100644 index 00000000..f8fbc0cd --- /dev/null +++ b/benchmarks/ckb-rpc.yml @@ -0,0 +1,112 @@ +# OpenChainBench. Bench No 219 + +slug: ckb-rpc +number: "219" +title: Fastest free Nervos CKB RPC, live no-key endpoint latency +seo_title: "Fastest free Nervos CKB RPC 2026" +seo_description: "{{best_name}} leads free Nervos CKB RPC at {{best_p50}} (get_tip_block_number p50, 24h). 2 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for get_tip_block_number against every available public Nervos CKB node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Nervos CKB (Common Knowledge Base) is a proof-of-work Layer 1 blockchain using the NC-MAX consensus protocol, a variant of Nakamoto consensus with improved selfish-mining resistance. CKB targets roughly one block every 10 seconds with probabilistic finality. Public JSON-RPC endpoints are available without an API key from the Nervos Foundation and CKBapp. Every provider was live-verified with consecutive get_tip_block_number probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Nervos CKB. + We measure the round-trip latency of a single JSON-RPC call + (get_tip_block_number) against every available public CKB node that + sustains continuous probing: 2 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 + CKB-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 CKB-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\":\"get_tip_block_number\",\"params\":[]}. Plain HTTP POST. The result field is a hex-encoded block number string (0x prefix)." + - "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 hex block number), 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=ckb. Provider coverage at launch: 2 endpoints (Nervos Foundation, CKBapp)." + +findings: + - "{{best_name}} currently leads Nervos CKB RPC at {{best_p50}} (get_tip_block_number p50, 24h) across 2 measured providers." + +faq: + - q: "What is the fastest free Nervos CKB RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (CKB block number p50 over the last 24h), measured against 2 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Nervos CKB RPC endpoints work without an API key?" + a: "2 endpoints sustain continuous keyless probing at launch: the Nervos Foundation node (mainnet.ckb.dev/rpc) and CKBapp (mainnet.ckbapp.dev/rpc). Every listed endpoint was live-verified with a get_tip_block_number call returning a parsable hex block number before inclusion." + - q: "Does the fastest CKB 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 Nervos CKB RPC latency measured here, technically?" + a: "One get_tip_block_number 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="ckb"}) + +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: ckb-dev + name: Nervos Foundation + tag: Nervos Foundation official CKB mainnet public RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a get_tip_block_number POST sent every 60s from 3 regions to mainnet.ckb.dev/rpc." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckb-dev", chain="ckb"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ckb-dev", chain="ckb"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ckb-dev", chain="ckb"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ckb-dev", chain="ckb"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ckb-dev", chain="ckb"}) / sum(ocb:rpc_call:rate_24h{provider="ckb-dev", chain="ckb"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ckb-dev", chain="ckb"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ckb-dev", chain="ckb"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckb-dev", chain="ckb", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ckb-dev", chain="ckb", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckb-dev", chain="ckb", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ckb-dev", chain="ckb", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckb-dev", chain="ckb", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ckb-dev", chain="ckb", region="sgp"}[1h]) + + - slug: ckbapp + name: CKBapp + tag: CKBapp community CKB mainnet public RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a get_tip_block_number POST sent every 60s from 3 regions to mainnet.ckbapp.dev/rpc." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckbapp", chain="ckb"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ckbapp", chain="ckb"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ckbapp", chain="ckb"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ckbapp", chain="ckb"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ckbapp", chain="ckb"}) / sum(ocb:rpc_call:rate_24h{provider="ckbapp", chain="ckb"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ckbapp", chain="ckb"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ckbapp", chain="ckb"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckbapp", chain="ckb", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ckbapp", chain="ckb", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckbapp", chain="ckb", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ckbapp", chain="ckb", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ckbapp", chain="ckb", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ckbapp", chain="ckb", region="sgp"}[1h]) diff --git a/benchmarks/flow-rpc.yml b/benchmarks/flow-rpc.yml new file mode 100644 index 00000000..cf2cbc49 --- /dev/null +++ b/benchmarks/flow-rpc.yml @@ -0,0 +1,112 @@ +# OpenChainBench. Bench No 217 + +slug: flow-rpc +number: "217" +title: Fastest free Flow RPC, live no-key endpoint latency +seo_title: "Fastest free Flow RPC 2026" +seo_description: "{{best_name}} leads free Flow RPC at {{best_p50}} (Cadence REST /v1/blocks sealed height p50, 24h). 2 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for the Flow Cadence REST endpoint (GET /v1/blocks?height=sealed) against every available public Flow node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Flow is a proof-of-stake L1 blockchain developed by Dapper Labs using a multi-role node architecture (Collector, Consensus, Execution, Verification) and the Cadence smart contract language. The Cadence chain commits roughly one block every 1 to 2 seconds with immediate deterministic finality. Public REST access nodes are operated by the Flow Foundation and accept GET /v1/blocks?height=sealed without an API key. Every provider was live-verified with consecutive sealed-block REST probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Flow. + We measure the round-trip latency of a single REST GET to + /v1/blocks?height=sealed against every available public Flow node + that sustains continuous probing: 2 providers at launch, every + 60 seconds, from us-east, eu-west and Singapore. The harness + classifies every response (ok / http_err / stale / timeout) with + a Flow-scaled staleness gap (240 blocks, around 5 min). The + cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the Flow-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 to /v1/blocks?height=sealed with Accept: application/json. Pure REST endpoint, no API key. The response is a JSON array; [0].header.height is parsed as a decimal string." + - "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), http_err, stale (block more than 240 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=flow. Provider coverage at launch: 2 endpoints (Flow Foundation REST, Flow access node)." + +findings: + - "{{best_name}} currently leads Flow RPC at {{best_p50}} (Cadence REST /v1/blocks sealed height p50, 24h) across 2 measured providers." + +faq: + - q: "What is the fastest free Flow RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Flow sealed block height p50 over the last 24h), measured against 2 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Flow RPC endpoints work without an API key?" + a: "2 endpoints sustain continuous keyless probing at launch: the Flow Foundation REST node (rest-mainnet.onflow.org) and the Flow access node REST endpoint (access.mainnet.nodes.onflow.org). Every listed endpoint was live-verified with a GET /v1/blocks?height=sealed returning a parsable height before inclusion." + - q: "Does the fastest Flow 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 Flow RPC latency measured here, technically?" + a: "One REST GET to /v1/blocks?height=sealed 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="flow"}) + +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: onflow + name: Flow Foundation + tag: Flow Foundation official public REST node, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/blocks?height=sealed sent every 60s from 3 regions to rest-mainnet.onflow.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onflow", chain="flow"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="onflow", chain="flow"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="onflow", chain="flow"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="onflow", chain="flow"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="onflow", chain="flow"}) / sum(ocb:rpc_call:rate_24h{provider="onflow", chain="flow"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="onflow", chain="flow"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="onflow", chain="flow"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onflow", chain="flow", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onflow", chain="flow", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onflow", chain="flow", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onflow", chain="flow", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="onflow", chain="flow", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="onflow", chain="flow", region="sgp"}[1h]) + + - slug: flow-access + name: Flow Access Node + tag: Flow Foundation public access node REST API, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /v1/blocks?height=sealed sent every 60s from 3 regions to access.mainnet.nodes.onflow.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="flow-access", chain="flow"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="flow-access", chain="flow"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="flow-access", chain="flow"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="flow-access", chain="flow"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="flow-access", chain="flow"}) / sum(ocb:rpc_call:rate_24h{provider="flow-access", chain="flow"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="flow-access", chain="flow"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="flow-access", chain="flow"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="flow-access", chain="flow", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="flow-access", chain="flow", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="flow-access", chain="flow", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="flow-access", chain="flow", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="flow-access", chain="flow", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="flow-access", chain="flow", region="sgp"}[1h]) diff --git a/benchmarks/hedera-rpc.yml b/benchmarks/hedera-rpc.yml new file mode 100644 index 00000000..5369bc30 --- /dev/null +++ b/benchmarks/hedera-rpc.yml @@ -0,0 +1,112 @@ +# OpenChainBench. Bench No 218 + +slug: hedera-rpc +number: "218" +title: Fastest free Hedera RPC, live no-key endpoint latency +seo_title: "Fastest free Hedera RPC 2026" +seo_description: "{{best_name}} leads free Hedera RPC at {{best_p50}} (eth_getBlockByNumber EVM p50, 24h). 2 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for eth_getBlockByNumber against every available public Hedera EVM-compatible node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Hedera is a proof-of-stake public distributed ledger using the Hashgraph consensus algorithm (asynchronous Byzantine Fault Tolerant), targeting high throughput and deterministic finality in under 3 seconds. Hedera exposes an EVM-compatible JSON-RPC layer via Hashio, allowing standard eth_getBlockByNumber calls. Public EVM-compatible endpoints are available without an API key from Hashio (operated by the Hedera Foundation) 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 Hedera. + We measure the round-trip latency of a single eth_getBlockByNumber + ("latest", false) call against every available public Hedera EVM + node that sustains continuous probing: 2 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 Hedera-scaled staleness gap (100 blocks, around + 5 min at 3 s/block). The cross-chain view lives on the parent + rpc-capabilities benchmark; this page is the Hedera-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 — Hedera's Hashio layer is EVM-compatible." + - "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 (block more than 100 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=hedera. Provider coverage at launch: 2 endpoints (Hashio, thirdweb)." + +findings: + - "{{best_name}} currently leads Hedera RPC at {{best_p50}} (eth_getBlockByNumber p50, 24h) across 2 measured providers." + +faq: + - q: "What is the fastest free Hedera RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Hedera EVM block height p50 over the last 24h), measured against 2 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which Hedera RPC endpoints work without an API key?" + a: "2 endpoints sustain continuous keyless probing at launch: Hashio (mainnet.hashio.io/api, operated by the Hedera Foundation) and thirdweb (295.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 Hedera 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 Hedera 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="hedera"}) + +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: hashio + name: Hashio + tag: Hedera Foundation Hashio public EVM JSON-RPC endpoint, 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.hashio.io/api." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="hashio", chain="hedera"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="hashio", chain="hedera"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="hashio", chain="hedera"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="hashio", chain="hedera"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="hashio", chain="hedera"}) / sum(ocb:rpc_call:rate_24h{provider="hashio", chain="hedera"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="hashio", chain="hedera"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="hashio", chain="hedera"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="hashio", chain="hedera", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="hashio", chain="hedera", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="hashio", chain="hedera", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="hashio", chain="hedera", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="hashio", chain="hedera", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="hashio", chain="hedera", region="sgp"}[1h]) + + - slug: thirdweb + name: thirdweb + tag: thirdweb public RPC for Hedera EVM (chain 295), 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 295.rpc.thirdweb.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="hedera"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="thirdweb", chain="hedera"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="thirdweb", chain="hedera"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="thirdweb", chain="hedera"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="thirdweb", chain="hedera"}) / sum(ocb:rpc_call:rate_24h{provider="thirdweb", chain="hedera"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="thirdweb", chain="hedera"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="hedera"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="hedera", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="hedera", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="hedera", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="hedera", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="thirdweb", chain="hedera", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="thirdweb", chain="hedera", region="sgp"}[1h]) diff --git a/benchmarks/multiversx-rpc.yml b/benchmarks/multiversx-rpc.yml new file mode 100644 index 00000000..b8dcf82d --- /dev/null +++ b/benchmarks/multiversx-rpc.yml @@ -0,0 +1,112 @@ +# OpenChainBench. Bench No 220 + +slug: multiversx-rpc +number: "220" +title: Fastest free MultiversX RPC, live no-key endpoint latency +seo_title: "Fastest free MultiversX RPC 2026" +seo_description: "{{best_name}} leads free MultiversX RPC at {{best_p50}} (metachain erd_nonce p50, 24h). 2 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for GET /network/status/4294967295 (metachain nonce) against every available public MultiversX node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + MultiversX (formerly Elrond) is a proof-of-stake L1 blockchain using Secure Proof of Stake (SPoS) with adaptive state sharding, supporting up to 15,000 TPS per shard. The metachain coordinates shard consensus and commits a nonce (block height) approximately every 6 seconds with immediate finality. Public gateway endpoints are available without an API key from the MultiversX Foundation. Every provider was live-verified with consecutive metachain status probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to MultiversX. + We measure the round-trip latency of a single REST GET to + /network/status/4294967295 (metachain) against every available public + MultiversX node that sustains continuous probing: 2 providers at launch, + every 60 seconds, from us-east, eu-west and Singapore. The harness + classifies every response (ok / http_err / stale / timeout) with a + MultiversX-scaled staleness gap (50 nonces, around 5 min at 6 s/nonce). + The cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the MultiversX-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 to /network/status/4294967295 with Accept: application/json. The shard ID 4294967295 (0xFFFFFFFF) is the MultiversX metachain identifier. The response carries data.status.erd_nonce as a decimal uint64." + - "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 erd_nonce), http_err, stale (nonce more than 50 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=multiversx. Provider coverage at launch: 2 endpoints (MultiversX Gateway, MultiversX API)." + +findings: + - "{{best_name}} currently leads MultiversX RPC at {{best_p50}} (metachain erd_nonce p50, 24h) across 2 measured providers." + +faq: + - q: "What is the fastest free MultiversX RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (MultiversX metachain nonce p50 over the last 24h), measured against 2 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which MultiversX RPC endpoints work without an API key?" + a: "2 endpoints sustain continuous keyless probing at launch: the MultiversX Gateway (gateway.multiversx.com) and the MultiversX API (api.multiversx.com). Every listed endpoint was live-verified with a GET /network/status/4294967295 returning a parsable erd_nonce before inclusion." + - q: "Does the fastest MultiversX 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 MultiversX RPC latency measured here, technically?" + a: "One GET /network/status/4294967295 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="multiversx"}) + +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: mvx-gateway + name: MultiversX Gateway + tag: MultiversX Foundation official gateway, public REST endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /network/status/4294967295 sent every 60s from 3 regions to gateway.multiversx.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-gateway", chain="multiversx"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="mvx-gateway", chain="multiversx"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="mvx-gateway", chain="multiversx"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="mvx-gateway", chain="multiversx"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="mvx-gateway", chain="multiversx"}) / sum(ocb:rpc_call:rate_24h{provider="mvx-gateway", chain="multiversx"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="mvx-gateway", chain="multiversx"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="mvx-gateway", chain="multiversx"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-gateway", chain="multiversx", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="mvx-gateway", chain="multiversx", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-gateway", chain="multiversx", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="mvx-gateway", chain="multiversx", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-gateway", chain="multiversx", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="mvx-gateway", chain="multiversx", region="sgp"}[1h]) + + - slug: mvx-api + name: MultiversX API + tag: MultiversX Foundation official API endpoint, public REST, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET /network/status/4294967295 sent every 60s from 3 regions to api.multiversx.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-api", chain="multiversx"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="mvx-api", chain="multiversx"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="mvx-api", chain="multiversx"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="mvx-api", chain="multiversx"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="mvx-api", chain="multiversx"}) / sum(ocb:rpc_call:rate_24h{provider="mvx-api", chain="multiversx"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="mvx-api", chain="multiversx"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="mvx-api", chain="multiversx"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-api", chain="multiversx", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="mvx-api", chain="multiversx", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-api", chain="multiversx", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="mvx-api", chain="multiversx", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="mvx-api", chain="multiversx", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="mvx-api", chain="multiversx", region="sgp"}[1h]) diff --git a/benchmarks/near-rpc.yml b/benchmarks/near-rpc.yml new file mode 100644 index 00000000..4065fae2 --- /dev/null +++ b/benchmarks/near-rpc.yml @@ -0,0 +1,157 @@ +# OpenChainBench. Bench No 216 + +slug: near-rpc +number: "216" +title: Fastest free NEAR RPC, live no-key endpoint latency +seo_title: "Fastest free NEAR Protocol RPC 2026" +seo_description: "{{best_name}} leads free NEAR RPC at {{best_p50}} (block/finality:final height p50, 24h). 4 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for block (finality=final) against every available public NEAR Protocol node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + NEAR Protocol is a sharded Proof-of-Stake L1 blockchain using Nightshade sharding and Doomslug consensus, targeting roughly one block per second with near-instant practical finality. Public JSON-RPC endpoints are available without an API key from the NEAR Foundation, FastNEAR, Lava Network and dRPC. Every provider was live-verified with consecutive block/finality:final probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to NEAR Protocol. + We measure the round-trip latency of a single JSON-RPC call (block with + finality=final) against every available public NEAR node that sustains + continuous probing: 4 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 NEAR-scaled + staleness gap (300 blocks, around 5 min). The cross-chain view lives on + the parent rpc-capabilities benchmark; this page is the NEAR-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\":\"block\",\"params\":{\"finality\":\"final\"}}. Plain HTTP POST. The response carries result.header.height as a decimal uint64." + - "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 result.header.height), http_err, jsonrpc_err, stale (block more than 300 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=near. Provider coverage at launch: 4 endpoints (NEAR Foundation, FastNEAR, Lava, dRPC)." + +findings: + - "{{best_name}} currently leads NEAR RPC at {{best_p50}} (block/finality:final height p50, 24h) across 4 measured providers." + +faq: + - q: "What is the fastest free NEAR Protocol RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (NEAR block height p50 over the last 24h), measured against 4 providers probed every 60 seconds from us-east, eu-west and Singapore. The leaderboard re-sorts continuously against fresh Prometheus samples." + - q: "Which NEAR RPC endpoints work without an API key?" + a: "4 endpoints sustain continuous keyless probing at launch: NEAR Foundation (rpc.mainnet.near.org), FastNEAR (free.rpc.fastnear.com), Lava (near.lava.build) and dRPC (near.drpc.org). Every listed endpoint was live-verified with a block/finality:final call returning a parsable height before inclusion." + - q: "Does the fastest NEAR 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 NEAR RPC latency measured here, technically?" + a: "One block/finality:final 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="near"}) + +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: near-org + name: NEAR Foundation + tag: Official NEAR Foundation public mainnet RPC, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a block/finality:final POST sent every 60s from 3 regions to rpc.mainnet.near.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="near-org", chain="near"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="near-org", chain="near"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="near-org", chain="near"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="near-org", chain="near"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="near-org", chain="near"}) / sum(ocb:rpc_call:rate_24h{provider="near-org", chain="near"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="near-org", chain="near"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="near-org", chain="near"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="near-org", chain="near", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="near-org", chain="near", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="near-org", chain="near", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="near-org", chain="near", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="near-org", chain="near", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="near-org", chain="near", region="sgp"}[1h]) + + - slug: fastnear + name: FastNEAR + tag: FastNEAR community RPC, free tier, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a block/finality:final POST sent every 60s from 3 regions to free.rpc.fastnear.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fastnear", chain="near"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="fastnear", chain="near"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="fastnear", chain="near"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="fastnear", chain="near"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="fastnear", chain="near"}) / sum(ocb:rpc_call:rate_24h{provider="fastnear", chain="near"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="fastnear", chain="near"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="fastnear", chain="near"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fastnear", chain="near", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="fastnear", chain="near", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fastnear", chain="near", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="fastnear", chain="near", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="fastnear", chain="near", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="fastnear", chain="near", region="sgp"}[1h]) + + - slug: lava + name: Lava + tag: Lava Network decentralised RPC, public NEAR endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a block/finality:final POST sent every 60s from 3 regions to near.lava.build." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="near"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="lava", chain="near"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="lava", chain="near"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="lava", chain="near"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="lava", chain="near"}) / sum(ocb:rpc_call:rate_24h{provider="lava", chain="near"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="lava", chain="near"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="lava", chain="near"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="near", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="lava", chain="near", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="near", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="lava", chain="near", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="near", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="lava", chain="near", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: dRPC decentralised multi-chain RPC, public NEAR endpoint, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a block/finality:final POST sent every 60s from 3 regions to near.drpc.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="near"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="near"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="near"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="near"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="near"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="near"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="near"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="near"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="near", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="near", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="near", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="near", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="near", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="near", region="sgp"}[1h]) diff --git a/benchmarks/neo-rpc.yml b/benchmarks/neo-rpc.yml new file mode 100644 index 00000000..96cd042a --- /dev/null +++ b/benchmarks/neo-rpc.yml @@ -0,0 +1,135 @@ +# OpenChainBench. Bench No 221 + +slug: neo-rpc +number: "221" +title: Fastest free NEO N3 RPC, live no-key endpoint latency +seo_title: "Fastest free NEO N3 RPC 2026" +seo_description: "{{best_name}} leads free NEO N3 RPC at {{best_p50}} (getblockcount p50, 24h). 3 providers measured every 60s from 3 regions." +subtitle: HTTP round-trip latency for getblockcount against every available public NEO N3 node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + NEO N3 is the third generation of the NEO blockchain, a delegated Byzantine Fault Tolerant (dBFT) proof-of-stake L1 blockchain targeting one block every 15 seconds with one-block deterministic finality. NEO N3 uses a dual-token model (NEO for governance/GAS generation, GAS for transaction fees) and supports smart contracts in multiple languages via the NeoVM. Public JSON-RPC endpoints are available without an API key from NSPCC and Neo Global Development. Every provider was live-verified with consecutive getblockcount probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to NEO N3. + We measure the round-trip latency of a single JSON-RPC call + (getblockcount) against every available public NEO N3 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 + NEO-scaled staleness gap (20 blocks, around 5 min at 15 s/block). + The cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the NEO N3-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\":\"getblockcount\",\"params\":[]}. Plain HTTP POST. The result is a decimal integer (block count = current height + 1)." + - "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 count), http_err, jsonrpc_err, stale (block more than 20 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=neo. Provider coverage at launch: 3 endpoints (NSPCC, NGD seed 1, NGD seed 2)." + +findings: + - "{{best_name}} currently leads NEO N3 RPC at {{best_p50}} (getblockcount p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free NEO N3 RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (NEO N3 block count 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 NEO N3 RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: NSPCC (rpc10.n3.nspcc.ru:10331), NGD seed node 1 (n3seed1.ngd.network:10332) and NGD seed node 2 (n3seed2.ngd.network:10332). Every listed endpoint was live-verified with a getblockcount call returning a parsable block count before inclusion." + - q: "Does the fastest NEO N3 RPC change by region?" + a: "Often. Public infra concentrates in specific regions; NSPCC is Russia-hosted and NGD nodes are in Asia, so latency rankings shift significantly by origin. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is NEO N3 RPC latency measured here, technically?" + a: "One getblockcount 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="neo"}) + +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: nspcc + name: NSPCC + tag: NSPCC NEO N3 public mainnet RPC node, keyless + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getblockcount POST sent every 60s from 3 regions to rpc10.n3.nspcc.ru:10331." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nspcc", chain="neo"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="nspcc", chain="neo"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="nspcc", chain="neo"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="nspcc", chain="neo"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="nspcc", chain="neo"}) / sum(ocb:rpc_call:rate_24h{provider="nspcc", chain="neo"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="nspcc", chain="neo"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="nspcc", chain="neo"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nspcc", chain="neo", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nspcc", chain="neo", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nspcc", chain="neo", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nspcc", chain="neo", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="nspcc", chain="neo", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="nspcc", chain="neo", region="sgp"}[1h]) + + - slug: ngd + name: NGD + tag: Neo Global Development seed node 1, public mainnet RPC, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getblockcount POST sent every 60s from 3 regions to n3seed1.ngd.network:10332." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd", chain="neo"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ngd", chain="neo"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ngd", chain="neo"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ngd", chain="neo"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ngd", chain="neo"}) / sum(ocb:rpc_call:rate_24h{provider="ngd", chain="neo"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ngd", chain="neo"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ngd", chain="neo"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd", chain="neo", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ngd", chain="neo", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd", chain="neo", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ngd", chain="neo", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd", chain="neo", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ngd", chain="neo", region="sgp"}[1h]) + + - slug: ngd2 + name: NGD (2) + tag: Neo Global Development seed node 2, public mainnet RPC, no key required + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a getblockcount POST sent every 60s from 3 regions to n3seed2.ngd.network:10332." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd2", chain="neo"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="ngd2", chain="neo"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="ngd2", chain="neo"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="ngd2", chain="neo"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="ngd2", chain="neo"}) / sum(ocb:rpc_call:rate_24h{provider="ngd2", chain="neo"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="ngd2", chain="neo"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="ngd2", chain="neo"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd2", chain="neo", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ngd2", chain="neo", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd2", chain="neo", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ngd2", chain="neo", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="ngd2", chain="neo", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="ngd2", chain="neo", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index 01ab39f6..46762b62 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -1551,6 +1551,69 @@ func chains() []Chain { {Slug: "uniblock", Name: "Uniblock", URL: envDefault("RPC_URL_GRAM_UNIBLOCK", "https://api.uniblock.dev/uni/v1/json-rpc?chainId=toncoin")}, }, }, + // NEAR Protocol — JSON-RPC block/finality:final, ~1 block/s. 4 keyless providers. + { + Slug: "near", + Name: "NEAR Protocol", + Kind: "near", + Providers: []Provider{ + {Slug: "near-org", Name: "NEAR Foundation", URL: envDefault("RPC_URL_NEAR_NEARORG", "https://rpc.mainnet.near.org")}, + {Slug: "fastnear", Name: "FastNEAR", URL: envDefault("RPC_URL_NEAR_FASTNEAR", "https://free.rpc.fastnear.com")}, + {Slug: "lava", Name: "Lava", URL: envDefault("RPC_URL_NEAR_LAVA", "https://near.lava.build")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_NEAR_DRPC", "https://near.drpc.org")}, + }, + }, + // Flow — Cadence REST GET /v1/blocks?height=sealed, ~1.25 s/block. 2 public REST nodes. + { + Slug: "flow", + Name: "Flow", + Kind: "flow", + Providers: []Provider{ + {Slug: "onflow", Name: "Flow Foundation", URL: envDefault("RPC_URL_FLOW_ONFLOW", "https://rest-mainnet.onflow.org")}, + {Slug: "flow-access", Name: "Flow Access Node", URL: envDefault("RPC_URL_FLOW_ACCESS", "https://access.mainnet.nodes.onflow.org")}, + }, + }, + // Hedera — EVM-compatible JSON-RPC (eth_getBlockByNumber), ~3 s/block. 2 keyless providers. + { + Slug: "hedera", + Name: "Hedera", + Kind: "hedera", + Providers: []Provider{ + {Slug: "hashio", Name: "Hashio", URL: envDefault("RPC_URL_HEDERA_HASHIO", "https://mainnet.hashio.io/api")}, + {Slug: "thirdweb", Name: "thirdweb", URL: envDefault("RPC_URL_HEDERA_THIRDWEB", "https://295.rpc.thirdweb.com")}, + }, + }, + // Nervos CKB — get_tip_block_number JSON-RPC (hex result), ~10 s/block. 2 keyless providers. + { + Slug: "ckb", + Name: "Nervos CKB", + Kind: "ckb", + Providers: []Provider{ + {Slug: "ckb-dev", Name: "Nervos Foundation", URL: envDefault("RPC_URL_CKB_CKBDEV", "https://mainnet.ckb.dev/rpc")}, + {Slug: "ckbapp", Name: "CKBapp", URL: envDefault("RPC_URL_CKB_CKBAPP", "https://mainnet.ckbapp.dev/rpc")}, + }, + }, + // MultiversX — REST GET /network/status/4294967295 erd_nonce, ~6 s/nonce. 2 keyless providers. + { + Slug: "multiversx", + Name: "MultiversX", + Kind: "multiversx", + Providers: []Provider{ + {Slug: "mvx-gateway", Name: "MultiversX Gateway", URL: envDefault("RPC_URL_MULTIVERSX_GATEWAY", "https://gateway.multiversx.com")}, + {Slug: "mvx-api", Name: "MultiversX API", URL: envDefault("RPC_URL_MULTIVERSX_API", "https://api.multiversx.com")}, + }, + }, + // NEO N3 — getblockcount JSON-RPC (decimal result), ~15 s/block. 3 keyless providers. + { + Slug: "neo", + Name: "NEO N3", + Kind: "neo", + Providers: []Provider{ + {Slug: "nspcc", Name: "NSPCC", URL: envDefault("RPC_URL_NEO_NSPCC", "https://rpc10.n3.nspcc.ru:10331")}, + {Slug: "ngd", Name: "NGD", URL: envDefault("RPC_URL_NEO_NGD", "https://n3seed1.ngd.network:10332")}, + {Slug: "ngd2", Name: "NGD (2)", URL: envDefault("RPC_URL_NEO_NGD2", "https://n3seed2.ngd.network:10332")}, + }, + }, } 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 dfd931ee..b27424ac 100644 --- a/harnesses/rpc-capabilities/cmd/script/probe.go +++ b/harnesses/rpc-capabilities/cmd/script/probe.go @@ -64,6 +64,22 @@ const ( // gramStaleSeqnoGap: TON/Gram masterchain seqno advances every ~5 s, // so 60 seqnos ≈ 5 min. gramStaleSeqnoGap uint64 = 60 + // nearStaleBlockGap: NEAR commits ~1 block/s, so 300 blocks ≈ 5 min. + nearStaleBlockGap uint64 = 300 + // flowStaleBlockGap: Flow Cadence commits one block every ~1.25 s, + // so 240 blocks ≈ 5 min. + flowStaleBlockGap uint64 = 240 + // hederaStaleBlockGap: Hedera EVM blocks every ~3 s, so 100 blocks ≈ 5 min. + hederaStaleBlockGap uint64 = 100 + // ckbStaleBlockGap: Nervos CKB commits one block every ~10 s, + // so 30 blocks ≈ 5 min. + ckbStaleBlockGap uint64 = 30 + // multiversxStaleNonceGap: MultiversX meta-chain nonce advances every ~6 s, + // so 50 nonces ≈ 5 min. + multiversxStaleNonceGap uint64 = 50 + // neoStaleBlockGap: NEO N3 commits one block every ~15 s, + // so 20 blocks ≈ 5 min. + neoStaleBlockGap uint64 = 20 ) // chainTips tracks the highest block seen for each chain across all @@ -242,6 +258,16 @@ func probeOne(ctx context.Context, c Chain, p Provider) { block, result, latency, err = callAlgorandStatus(probeCtx, p.URL) case "gram": block, result, latency, err = callGramSeqno(probeCtx, p.URL) + case "near": + block, result, latency, err = callNearBlock(probeCtx, p.URL) + case "flow": + block, result, latency, err = callFlowBlock(probeCtx, p.URL) + case "ckb": + block, result, latency, err = callCkbTipBlockNumber(probeCtx, p.URL) + case "multiversx": + block, result, latency, err = callMultiversxNonce(probeCtx, p.URL) + case "neo": + block, result, latency, err = callNeoBlockCount(probeCtx, p.URL) default: block, hash, result, latency, err = callLatestBlock(probeCtx, p.URL) } @@ -271,6 +297,18 @@ func probeOne(ctx context.Context, c Chain, p Provider) { gap = algorandStaleRoundGap case "gram": gap = gramStaleSeqnoGap + case "near": + gap = nearStaleBlockGap + case "flow": + gap = flowStaleBlockGap + case "hedera": + gap = hederaStaleBlockGap + case "ckb": + gap = ckbStaleBlockGap + case "multiversx": + gap = multiversxStaleNonceGap + case "neo": + gap = neoStaleBlockGap } if tip > 0 && block+gap < tip { result = "stale" @@ -290,7 +328,8 @@ func probeOne(ctx context.Context, c Chain, p Provider) { // hash normalisation across Cosmos chains is validated). switch c.Kind { case "solana", "polkadot", "cosmos", "starknet", "stellar", - "sui", "aptos", "xrpl", "algorand", "gram": + "sui", "aptos", "xrpl", "algorand", "gram", + "near", "flow", "hedera", "ckb", "multiversx", "neo": // no consensus participation default: if result == "ok" || result == "stale" { @@ -940,3 +979,275 @@ func callGramSeqno(ctx context.Context, url string) (seqno uint64, result string } return mc.Last.Seqno, "ok", latencyMs, nil } + +// nearBlockHeader is the shape of result.header in a NEAR `block` JSON-RPC response. +type nearBlockHeader struct { + Height uint64 `json:"height"` +} + +type nearBlockResult struct { + Header nearBlockHeader `json:"header"` +} + +// callNearBlock probes a NEAR node via the `block` JSON-RPC method with finality=final. +// Staleness uses nearStaleBlockGap in probeOne. +func callNearBlock(ctx context.Context, url string) (height uint64, result string, latencyMs float64, err error) { + body := []byte(fmt.Sprintf( + `{"jsonrpc":"2.0","method":"block","params":{"finality":"final"},"id":%d}`, + time.Now().UnixNano(), + )) + req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body)) + req.Header.Set("Content-Type", "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 r rpcBlockEnvelope + if err := json.Unmarshal(raw, &r); err != nil { + return 0, "http_err", latencyMs, err + } + if r.Error != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("rpc -%d: %s", r.Error.Code, r.Error.Message) + } + if len(r.Result) == 0 || string(r.Result) == "null" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("empty near result") + } + var blk nearBlockResult + if err := json.Unmarshal(r.Result, &blk); err != nil { + return 0, "jsonrpc_err", latencyMs, err + } + if blk.Header.Height == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("near block missing height") + } + return blk.Header.Height, "ok", latencyMs, nil +} + +// flowBlockEntry is the shape of one element in the array returned by +// GET /v1/blocks?height=sealed on the Flow Cadence REST API. +type flowBlockEntry struct { + Header struct { + Height string `json:"height"` + } `json:"header"` +} + +// callFlowBlock probes a Flow node via the Cadence REST endpoint GET /v1/blocks?height=sealed. +// The height field is a decimal string. Staleness uses flowStaleBlockGap in probeOne. +func callFlowBlock(ctx context.Context, url string) (height uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/v1/blocks?height=sealed" + 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 blocks []flowBlockEntry + if err := json.Unmarshal(raw, &blocks); err != nil { + return 0, "http_err", latencyMs, err + } + if len(blocks) == 0 || blocks[0].Header.Height == "" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("flow blocks response empty or missing height") + } + n, err := strconv.ParseUint(blocks[0].Header.Height, 10, 64) + if err != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("non-numeric flow height: %s", blocks[0].Header.Height[:min(len(blocks[0].Header.Height), 40)]) + } + return n, "ok", latencyMs, nil +} + +// callCkbTipBlockNumber probes a Nervos CKB node via get_tip_block_number JSON-RPC. +// The result is a hex string ("0x..."). Staleness uses ckbStaleBlockGap in probeOne. +func callCkbTipBlockNumber(ctx context.Context, url string) (height uint64, result string, latencyMs float64, err error) { + body := []byte(fmt.Sprintf( + `{"jsonrpc":"2.0","method":"get_tip_block_number","params":[],"id":%d}`, + time.Now().UnixNano(), + )) + req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body)) + req.Header.Set("Content-Type", "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 r rpcBlockEnvelope + if err := json.Unmarshal(raw, &r); err != nil { + return 0, "http_err", latencyMs, err + } + if r.Error != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("rpc -%d: %s", r.Error.Code, r.Error.Message) + } + if len(r.Result) == 0 || string(r.Result) == "null" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("empty ckb result") + } + var hexStr string + if err := json.Unmarshal(r.Result, &hexStr); err != nil { + return 0, "jsonrpc_err", latencyMs, err + } + n, err := strconv.ParseUint(strings.TrimPrefix(hexStr, "0x"), 16, 64) + if err != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("non-hex ckb block number: %s", hexStr[:min(len(hexStr), 40)]) + } + return n, "ok", latencyMs, nil +} + +// multiversxNetworkStatus is the shape of GET /network/status/4294967295 on MultiversX gateway. +type multiversxNetworkStatus struct { + Data struct { + Status struct { + ErdNonce uint64 `json:"erd_nonce"` + } `json:"status"` + } `json:"data"` + Code string `json:"code"` +} + +// callMultiversxNonce probes a MultiversX node via GET /network/status/4294967295 (metachain). +// erd_nonce is the metachain block nonce (analogous to block height). +// Staleness uses multiversxStaleNonceGap in probeOne. +func callMultiversxNonce(ctx context.Context, url string) (nonce uint64, result string, latencyMs float64, err error) { + target := strings.TrimRight(url, "/") + "/network/status/4294967295" + 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 st multiversxNetworkStatus + if err := json.Unmarshal(raw, &st); err != nil { + return 0, "http_err", latencyMs, err + } + if st.Code != "successful" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("multiversx status code: %s", st.Code) + } + if st.Data.Status.ErdNonce == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("multiversx missing erd_nonce") + } + return st.Data.Status.ErdNonce, "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) { + body := []byte(fmt.Sprintf( + `{"jsonrpc":"2.0","method":"getblockcount","params":[],"id":%d}`, + time.Now().UnixNano(), + )) + req, _ := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(body)) + req.Header.Set("Content-Type", "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 r rpcBlockEnvelope + if err := json.Unmarshal(raw, &r); err != nil { + return 0, "http_err", latencyMs, err + } + if r.Error != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("rpc -%d: %s", r.Error.Code, r.Error.Message) + } + if len(r.Result) == 0 || string(r.Result) == "null" { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("empty neo result") + } + var n uint64 + if err := json.Unmarshal(r.Result, &n); err != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("non-numeric neo block count: %s", string(r.Result)[:min(len(r.Result), 40)]) + } + return n, "ok", latencyMs, nil +} diff --git a/public/logos/ckb.png b/public/logos/ckb.png new file mode 100644 index 0000000000000000000000000000000000000000..625d1b97ccc6a2a8848b0471a84ee7ec6ae21130 GIT binary patch literal 1535 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 RY4895002ovPDHLkV1hT>AJ+f? literal 0 HcmV?d00001 diff --git a/public/logos/flow.svg b/public/logos/flow.svg new file mode 100644 index 00000000..12a0f6be --- /dev/null +++ b/public/logos/flow.svg @@ -0,0 +1,6 @@ + + + + + + diff --git a/public/logos/multiversx.png b/public/logos/multiversx.png new file mode 100644 index 0000000000000000000000000000000000000000..538a0325a1e6387c29d8ae1c2e63b5e9e9a1e193 GIT binary patch literal 9024 zcmV-GBfs2004R>004l5008;`004mK004C`008P>0026e000+ooVrmw001J( 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 literal 0 HcmV?d00001 diff --git a/public/logos/neo.png b/public/logos/neo.png new file mode 100644 index 0000000000000000000000000000000000000000..1968da6f5fe54541f8e63bc0701e34ac522dea7e GIT binary patch literal 2912 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 = { "Uniblock is a multi-chain RPC aggregator providing unified access to TON and other blockchains via a public JSON-RPC endpoint, no API key required.", twitter: "@UniblockDev", }, + // ─── NEAR Protocol providers (bench 216) ───────────────────────── + "near-org": { + url: "https://near.org", + description: + "Official NEAR Foundation public mainnet RPC endpoint (rpc.mainnet.near.org). Provides JSON-RPC access to the NEAR Protocol without an API key.", + twitter: "@NEARProtocol", + }, + fastnear: { + url: "https://fastnear.com", + description: + "FastNEAR is a high-performance NEAR Protocol RPC service offering a free public tier at free.rpc.fastnear.com, no API key required.", + twitter: "@fastnear", + }, + // ─── Flow providers (bench 217) ────────────────────────────────── + onflow: { + url: "https://flow.com", + description: + "Flow Foundation official public REST access node (rest-mainnet.onflow.org). Provides the Cadence REST API for block queries without an API key.", + twitter: "@flow_blockchain", + }, + "flow-access": { + url: "https://flow.com", + description: + "Flow Foundation public access node (access.mainnet.nodes.onflow.org) exposing the Cadence REST API for sealed block queries, no API key required.", + twitter: "@flow_blockchain", + parent: "onflow", + }, + // ─── Hedera providers (bench 218) ──────────────────────────────── + hashio: { + url: "https://swirldslabs.com/hashio", + description: + "Hashio is a free public EVM-compatible JSON-RPC gateway for Hedera Hashgraph, operated by Swirlds Labs. No API key required; supports standard Ethereum JSON-RPC 2.0 methods.", + twitter: "@SwirldsLabs", + }, + // ─── CKB providers (bench 219) ─────────────────────────────────── + "ckb-dev": { + url: "https://nervos.org", + description: + "Nervos Foundation official CKB mainnet public RPC node (mainnet.ckb.dev/rpc). Provides JSON-RPC access to the Nervos CKB Layer 1 without an API key.", + twitter: "@NervosNetwork", + }, + ckbapp: { + url: "https://ckbapp.dev", + description: + "CKBapp community-operated Nervos CKB mainnet public RPC node (mainnet.ckbapp.dev/rpc). Provides JSON-RPC access without an API key.", + }, + // ─── MultiversX providers (bench 220) ──────────────────────────── + "mvx-gateway": { + url: "https://multiversx.com", + description: + "MultiversX Foundation official gateway node (gateway.multiversx.com). Provides public REST API access to MultiversX blockchain data including metachain network status, no API key required.", + twitter: "@MultiversX", + }, + "mvx-api": { + url: "https://api.multiversx.com", + description: + "MultiversX Foundation official API service (api.multiversx.com). Exposes REST endpoints including network status for indexer and gateway queries without an API key.", + twitter: "@MultiversX", + parent: "mvx-gateway", + }, + // ─── NEO N3 providers (bench 221) ──────────────────────────────── + nspcc: { + url: "https://nspcc.ru", + description: + "NSPCC (Russian National Crypto Standard Committee) operates a public NEO N3 mainnet RPC node at rpc10.n3.nspcc.ru:10331. No API key required.", + }, + ngd: { + url: "https://neo.org", + description: + "Neo Global Development (NGD) operates public NEO N3 mainnet seed nodes (n3seed1.ngd.network:10332). No API key required.", + twitter: "@Neo_Blockchain", + }, + ngd2: { + url: "https://neo.org", + description: + "Neo Global Development (NGD) seed node 2 (n3seed2.ngd.network:10332) for NEO N3 mainnet. No API key required.", + twitter: "@Neo_Blockchain", + parent: "ngd", + }, }; /** diff --git a/src/lib/brand.ts b/src/lib/brand.ts index 58aa3de4..c6bd867e 100644 --- a/src/lib/brand.ts +++ b/src/lib/brand.ts @@ -107,6 +107,28 @@ const BRANDS: Record = { uniblock: { color: "#1FB6FF" }, // uniblock cyan nodely: { color: "#F9B72B" }, // nodely amber + // ─── Non-EVM L1s wave 2 (benches 216-221) ─── + near: { color: "#00C27E" }, // near green (official brand) + flow: { color: "#00EF8B" }, // flow green (primary brand) + hedera: { color: "#222222", dark: true }, // hedera dark (official brand) + ckb: { color: "#3CC68A" }, // nervos ckb teal + multiversx: { color: "#23F7DD" }, // multiversx teal/cyan + neo: { color: "#00AF92" }, // neo teal (brand kit) + + // ─── New providers (benches 216-221) ─── + fastnear: { color: "#00C27E" }, // fastnear inherits near green + hashio: { color: "#222222", dark: true }, // hashio inherits hedera dark + "ckb-dev": { color: "#3CC68A" }, // nervos foundation teal + ckbapp: { color: "#3CC68A" }, // ckbapp teal + "mvx-gateway": { color: "#23F7DD" }, // multiversx teal + "mvx-api": { color: "#23F7DD" }, // multiversx teal + nspcc: { color: "#1565C0", dark: true }, // nspcc deep blue + ngd: { color: "#00AF92" }, // ngd inherits neo teal + ngd2: { color: "#00AF92" }, // ngd2 inherits neo teal + onflow: { color: "#00EF8B" }, // onflow inherits flow green + "flow-access": { color: "#00EF8B" }, // flow access inherits flow green + "near-org": { color: "#00C27E" }, // near foundation inherits near green + // ─── Stellar ecosystem providers (bench № 210) ─── gateway: { color: "#00C2A8" }, // gateway.fm teal sorobanrpc: { color: "#7B4FBF" }, // sorobanrpc violet diff --git a/src/lib/chains.ts b/src/lib/chains.ts index 2b8891c4..bbf119d3 100644 --- a/src/lib/chains.ts +++ b/src/lib/chains.ts @@ -1123,6 +1123,60 @@ export const CHAINS: ChainEntry[] = [ description: "Polkadot parachain purpose-built for DePIN (Decentralised Physical Infrastructure Networks) with machine identity, machine staking, and role-based access control primitives for IoT and mobility networks.", }, + { + slug: "near", + label: "NEAR Protocol", + category: "L1", + nativeSymbol: "NEAR", + website: "https://near.org", + description: + "Sharded proof-of-stake L1 using Nightshade sharding and Doomslug consensus, targeting roughly one block per second with near-instant practical finality and human-readable account names.", + }, + { + slug: "flow", + label: "Flow", + category: "L1", + nativeSymbol: "FLOW", + website: "https://flow.com", + description: + "Proof-of-stake L1 developed by Dapper Labs using a multi-role node architecture (Collector, Consensus, Execution, Verification) and the Cadence resource-oriented smart contract language.", + }, + { + slug: "hedera", + label: "Hedera", + category: "L1", + nativeSymbol: "HBAR", + website: "https://hedera.com", + description: + "Enterprise-grade public distributed ledger governed by the Hedera Governing Council using the Hashgraph consensus algorithm, targeting high throughput with deterministic finality under 3 seconds.", + }, + { + slug: "ckb", + label: "Nervos CKB", + category: "L1", + nativeSymbol: "CKB", + website: "https://nervos.org", + description: + "Layer 1 proof-of-work blockchain using NC-MAX consensus (a selfish-mining-resistant Nakamoto variant) with a cell model for state storage and the RISC-V based CKB-VM for smart contract execution.", + }, + { + slug: "multiversx", + label: "MultiversX", + category: "L1", + nativeSymbol: "EGLD", + website: "https://multiversx.com", + description: + "Adaptive state-sharded proof-of-stake L1 using Secure Proof of Stake (SPoS) with a metachain coordinating shard consensus, targeting up to 15,000 TPS per shard with immediate deterministic finality.", + }, + { + slug: "neo", + label: "NEO N3", + category: "L1", + nativeSymbol: "NEO", + website: "https://neo.org", + description: + "Delegated Byzantine Fault Tolerant (dBFT) proof-of-stake L1 blockchain with one-block finality, a dual-token model (NEO for governance and GAS for fees), and the NeoVM supporting multiple smart contract languages.", + }, ]; export const CHAIN_BY_SLUG = new Map(CHAINS.map((c) => [c.slug, c])); diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index dbdad5ad..5039533c 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -183,6 +183,32 @@ const RAW: Record = { nownodes: "/logos/nownodes.svg", tatum: "/logos/tatum.svg", uniblock: "/logos/uniblock.svg", + // ─── Wave-2 non-EVM chains (benches 216-221) ─── + near: "/logos/near.jpg", + flow: "/logos/flow.png", + ckb: "/logos/ckb.png", + multiversx: "/logos/multiversx.png", + neo: "/logos/neo.png", + // ─── NEAR providers (bench 216) ─── + "near-org": "/logos/near.jpg", + fastnear: "/logos/near.jpg", + // lava already registered; drpc already registered + // ─── Flow providers (bench 217) ─── + onflow: "/logos/flow.png", + "flow-access": "/logos/flow.png", + // ─── Hedera providers (bench 218) ─── + hashio: "/logos/hedera.svg", + // thirdweb already registered + // ─── CKB providers (bench 219) ─── + "ckb-dev": "/logos/ckb.png", + ckbapp: "/logos/ckb.png", + // ─── MultiversX providers (bench 220) ─── + "mvx-gateway": "/logos/multiversx.png", + "mvx-api": "/logos/multiversx.png", + // ─── NEO providers (bench 221) ─── + nspcc: "/logos/neo.png", + ngd: "/logos/neo.png", + ngd2: "/logos/neo.png", infura: "/logos/infura.png", ankr: "/logos/ankr.png", chainstack: "/logos/chainstack.svg",