diff --git a/benchmarks/dogecoin-rpc.yml b/benchmarks/dogecoin-rpc.yml new file mode 100644 index 00000000..f5e75d52 --- /dev/null +++ b/benchmarks/dogecoin-rpc.yml @@ -0,0 +1,139 @@ +# OpenChainBench. Bench No 235 + +slug: dogecoin-rpc +number: "235" +title: Fastest free Dogecoin RPC, live no-key endpoint latency +seo_title: "Fastest free Dogecoin RPC 2026" +seo_description: "{{best_name}} leads free Dogecoin 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 Dogecoin node, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Dogecoin is a proof-of-work UTXO blockchain forked from Litecoin (itself a Bitcoin fork) and launched in December 2013. It targets one block every 60 seconds using the Scrypt hashing algorithm and has no hard supply cap. Dogecoin exposes a Bitcoin-compatible JSON-RPC interface — most node implementations accept `getblockcount` as a standard method. Public endpoints are available without an API key from Tatum, dRPC and BlockCypher. BlockCypher exposes a REST API instead of JSON-RPC, returning the current chain height via a GET request to its blockchain info endpoint. Every provider was live-verified with consecutive block-height probes at launch. + +abstract: | + Per-chain member of the RPC latency cluster, extended to Dogecoin. + We measure the round-trip latency of a block-height query against + every available public Dogecoin node that sustains continuous probing: + 3 providers at launch, every 60 seconds, from us-east, eu-west and + Singapore. Tatum and dRPC are probed via JSON-RPC POST (getblockcount); + BlockCypher via REST GET of its blockchain info endpoint. The harness + classifies every response (ok / http_err / jsonrpc_err / stale / timeout) + with a Dogecoin-scaled staleness gap (5 blocks, around 5 min at 60 s/block). + The cross-chain view lives on the parent rpc-capabilities benchmark; + this page is the Dogecoin-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 (Tatum, dRPC): {\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"getblockcount\",\"params\":[]}. Plain HTTP POST. The result is a decimal integer (block count = current height + 1)." + - "Payload (BlockCypher): GET https://api.blockcypher.com/v1/doge/main. Returns a JSON object with a `height` field containing the current block height." + - "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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 5 behind the cross-provider tip), timeout. Latency without reliability is a misleading ranking signal." + - "This page is part of the per-chain RPC cluster derived from the cross-chain rpc-capabilities benchmark; the identical harness, cadence and exclusion rules apply on every chain." + - "Chain scope: every query on this page is pinned to chain=dogecoin. Provider coverage at launch: 3 endpoints (Tatum, dRPC, BlockCypher)." + +findings: + - "{{best_name}} currently leads Dogecoin RPC at {{best_p50}} (getblockcount p50, 24h) across 3 measured providers." + +faq: + - q: "What is the fastest free Dogecoin RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (Dogecoin 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 Dogecoin RPC endpoints work without an API key?" + a: "3 endpoints sustain continuous keyless probing at launch: Tatum (dogecoin-mainnet.gateway.tatum.io, JSON-RPC), dRPC (dogecoin.drpc.org, JSON-RPC) and BlockCypher (api.blockcypher.com/v1/doge/main, REST GET). Every listed endpoint was live-verified with a block-height probe returning a parsable result before inclusion." + - q: "Does the fastest Dogecoin RPC change by region?" + a: "Often. dRPC routes through a decentralized mesh so latency varies by origin region; Tatum and BlockCypher have fixed infrastructure, so latency rankings can shift significantly depending on your geographic origin. The region tabs at the top of the page re-scope every number to a single origin." + - q: "How is Dogecoin RPC latency measured here, technically?" + a: "One block-height probe 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. Tatum and dRPC use JSON-RPC POST (getblockcount); BlockCypher uses REST GET of its blockchain info endpoint. 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." + - q: "Why does BlockCypher use a different API method than the other Dogecoin providers?" + a: "BlockCypher exposes a proprietary REST API rather than a Bitcoin-compatible JSON-RPC interface. Instead of getblockcount, we send a GET request to its blockchain info endpoint, which returns a JSON object with a height field. The measurement logic is identical: client-side round-trip in milliseconds, classified as ok when a parsable block height is returned." + +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="dogecoin"}) + +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: tatum + name: Tatum + tag: Tatum public Dogecoin RPC gateway, no API 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 dogecoin-mainnet.gateway.tatum.io." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="dogecoin"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="tatum", chain="dogecoin"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="tatum", chain="dogecoin"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="tatum", chain="dogecoin"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="tatum", chain="dogecoin"}) / sum(ocb:rpc_call:rate_24h{provider="tatum", chain="dogecoin"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="tatum", chain="dogecoin"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="dogecoin"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="dogecoin", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="dogecoin", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="dogecoin", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="dogecoin", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="tatum", chain="dogecoin", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="tatum", chain="dogecoin", region="sgp"}[1h]) + + - slug: drpc + name: dRPC + tag: dRPC decentralized RPC mesh, Dogecoin public endpoint, 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 dogecoin.drpc.org." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="dogecoin"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="drpc", chain="dogecoin"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="drpc", chain="dogecoin"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="drpc", chain="dogecoin"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="drpc", chain="dogecoin"}) / sum(ocb:rpc_call:rate_24h{provider="drpc", chain="dogecoin"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="drpc", chain="dogecoin"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="dogecoin"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="dogecoin", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="dogecoin", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="dogecoin", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="dogecoin", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="drpc", chain="dogecoin", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="drpc", chain="dogecoin", region="sgp"}[1h]) + + - slug: blockcypher + name: BlockCypher + tag: BlockCypher public Dogecoin REST API, no API key required for basic queries + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a GET request sent every 60s from 3 regions to api.blockcypher.com/v1/doge/main." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockcypher", chain="dogecoin"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="blockcypher", chain="dogecoin"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="blockcypher", chain="dogecoin"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="blockcypher", chain="dogecoin"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="blockcypher", chain="dogecoin"}) / sum(ocb:rpc_call:rate_24h{provider="blockcypher", chain="dogecoin"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="blockcypher", chain="dogecoin"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="blockcypher", chain="dogecoin"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockcypher", chain="dogecoin", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="blockcypher", chain="dogecoin", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockcypher", chain="dogecoin", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="blockcypher", chain="dogecoin", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="blockcypher", chain="dogecoin", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="blockcypher", chain="dogecoin", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index dbfadb58..ae11e0b6 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -1629,6 +1629,17 @@ func chains() []Chain { {Slug: "ngd2", Name: "NGD (2)", URL: envDefault("RPC_URL_NEO_NGD2", "https://n3seed2.ngd.network:10332")}, }, }, + // 2026-08-23 wave-9. Dogecoin — getblockcount JSON-RPC (Tatum, dRPC) + BlockCypher REST GET. ~60 s/block. + { + Slug: "dogecoin", + Name: "Dogecoin", + Kind: "dogecoin", + Providers: []Provider{ + {Slug: "tatum", Name: "Tatum", URL: envDefault("RPC_URL_DOGECOIN_TATUM", "https://dogecoin-mainnet.gateway.tatum.io")}, + {Slug: "drpc", Name: "dRPC", URL: envDefault("RPC_URL_DOGECOIN_DRPC", "https://dogecoin.drpc.org")}, + {Slug: "blockcypher", Name: "BlockCypher", URL: envDefault("RPC_URL_DOGECOIN_BLOCKCYPHER", "https://api.blockcypher.com/v1/doge/main")}, + }, + }, // 2026-08-18 wave-8. Tezos L1 — REST GET /chains/main/blocks/head/header, ~30 s/block. 4 keyless providers. { Slug: "tezos", diff --git a/harnesses/rpc-capabilities/cmd/script/probe.go b/harnesses/rpc-capabilities/cmd/script/probe.go index 4f402000..a54ba656 100644 --- a/harnesses/rpc-capabilities/cmd/script/probe.go +++ b/harnesses/rpc-capabilities/cmd/script/probe.go @@ -89,6 +89,9 @@ const ( // wavesStaleBlockGap: Waves closes a block every ~60 s, // so 5 blocks ≈ 5 min. wavesStaleBlockGap uint64 = 5 + // dogecoinStaleBlockGap: Dogecoin produces one block every ~60 s, + // so 5 blocks ≈ 5 min gives the same reliability tolerance as EVM. + dogecoinStaleBlockGap uint64 = 5 // veChainStaleBlockGap: VeChain produces one block every ~10 s, // so 30 blocks ≈ 5 min. veChainStaleBlockGap uint64 = 30 @@ -280,6 +283,12 @@ func probeOne(ctx context.Context, c Chain, p Provider) { block, result, latency, err = callMultiversxNonce(probeCtx, p.URL) case "neo": block, result, latency, err = callNeoBlockCount(probeCtx, p.URL) + case "dogecoin": + if strings.Contains(p.URL, "blockcypher.com") { + block, result, latency, err = callBlockCypherDoge(probeCtx, p.URL) + } else { + block, result, latency, err = callNeoBlockCount(probeCtx, p.URL) + } case "tezos": block, result, latency, err = callTezosBlock(probeCtx, p.URL) case "antelope": @@ -329,6 +338,8 @@ func probeOne(ctx context.Context, c Chain, p Provider) { gap = multiversxStaleNonceGap case "neo": gap = neoStaleBlockGap + case "dogecoin": + gap = dogecoinStaleBlockGap case "tezos": gap = tezosStaleBlockGap case "antelope": @@ -358,7 +369,7 @@ func probeOne(ctx context.Context, c Chain, p Provider) { case "solana", "polkadot", "cosmos", "starknet", "stellar", "sui", "aptos", "xrpl", "algorand", "gram", "near", "flow", "hedera", "ckb", "multiversx", "neo", - "tezos", "antelope", "waves", "vechain": + "tezos", "antelope", "waves", "vechain", "dogecoin": // no consensus participation default: if result == "ok" || result == "stale" { @@ -1466,3 +1477,39 @@ func callNeoBlockCount(ctx context.Context, url string) (count uint64, result st } return n, "ok", latencyMs, nil } + +// callBlockCypherDoge probes the BlockCypher REST API for Dogecoin mainnet. +// GET https://api.blockcypher.com/v1/doge/main — reads the `height` field. +func callBlockCypherDoge(ctx context.Context, url string) (height uint64, result string, latencyMs float64, err error) { + req, _ := http.NewRequestWithContext(ctx, "GET", url, nil) + 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) + } + + var body struct { + Height uint64 `json:"height"` + } + if err := json.NewDecoder(resp.Body).Decode(&body); err != nil { + return 0, "http_err", latencyMs, err + } + if body.Height == 0 { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("blockcypher doge: height=0") + } + return body.Height, "ok", latencyMs, nil +} diff --git a/public/logos/blockcypher.svg b/public/logos/blockcypher.svg new file mode 100644 index 00000000..699665be --- /dev/null +++ b/public/logos/blockcypher.svg @@ -0,0 +1,96 @@ + +image/svg+xml diff --git a/src/data/provider-registry.ts b/src/data/provider-registry.ts index 458875cf..f02e19e7 100644 --- a/src/data/provider-registry.ts +++ b/src/data/provider-registry.ts @@ -2526,6 +2526,14 @@ export const PROVIDER_REGISTRY: Record = { "TCInfra RPC node provider for Tezos and Etherlink (prod.tcinfra.net/rpc/mainnet). Provides public keyless Tezos mainnet REST access with no API key required.", }, + // ─── Dogecoin providers (bench 235) ────────────────────────── + blockcypher: { + url: "https://blockcypher.com", + description: + "BlockCypher is a blockchain API platform supporting Bitcoin, Litecoin, Dogecoin and Ethereum. Provides a public REST API for chain info, transactions and addresses, no API key required for basic queries.", + twitter: "@BlockCypher", + }, + // ─── OKTC providers (bench 231) ─────────────────────────────── "oktc-official": { url: "https://www.okx.com/oktc", diff --git a/src/lib/brand.ts b/src/lib/brand.ts index 2b5ad430..51d0701c 100644 --- a/src/lib/brand.ts +++ b/src/lib/brand.ts @@ -168,6 +168,9 @@ const BRANDS: Record = { tcinfra: { color: "#2C7DF7" }, // tcinfra tezos blue "oktc-official": { color: "#101010", dark: true }, // okx dark + // ─── Dogecoin providers (bench 235) ─── + blockcypher: { color: "#1565C0", dark: true }, // blockcypher deep blue + // ─── Stellar ecosystem providers (bench № 210) ─── gateway: { color: "#00C2A8" }, // gateway.fm teal sorobanrpc: { color: "#7B4FBF" }, // sorobanrpc violet diff --git a/src/lib/logo-manifest.ts b/src/lib/logo-manifest.ts index e82931bc..c2ddd3d4 100644 --- a/src/lib/logo-manifest.ts +++ b/src/lib/logo-manifest.ts @@ -327,6 +327,7 @@ const RAW: Record = { // (pairs alias to chain/asset logos in the ALIASES block below) chainlink: "/logos/chainlink.svg", dogecoin: "/logos/dogecoin.png", + blockcypher: "/logos/blockcypher.svg", // ─── Data / API providers (alternatives + products pages) ─── alchemy: "/logos/alchemy.svg",