diff --git a/benchmarks/solana-rpc.yml b/benchmarks/solana-rpc.yml new file mode 100644 index 00000000..63a32c21 --- /dev/null +++ b/benchmarks/solana-rpc.yml @@ -0,0 +1,190 @@ +# OpenChainBench. Bench № 075 + +slug: solana-rpc +number: "075" +title: Fastest free Solana RPC, live no-key endpoint latency +seo_title: "Fastest free Solana RPC 2026" +seo_description: "{{best_name}} leads free Solana RPC at {{best_p50}} (getSlot p50, 24h). 5 no-key providers measured every 60s from 3 regions, keyless." +subtitle: HTTP round-trip latency for getSlot at the processed commitment against every free, no-key public Solana RPC endpoint, audited every 60 seconds from 3 regions. + +category: RPCs +status: live +metric: RPC latency +unit: ms +higher_is_better: false + +seo_intro: | + Solana is the first non-EVM member of the RPC latency cluster, and the chain where the free-RPC question is asked most and answered worst: most "best Solana RPC" roundups list endpoints that key-gated or died years ago. This page probes the 5 endpoints that actually answer keyless today, including the Solana Labs official api.mainnet-beta.solana.com that every tutorial pastes, with the same rules as the 20 EVM chains in the cluster: one identical probe (getSlot at the processed commitment) every 60 seconds from us-east, eu-west and Singapore, stale-slot detection against the cross-provider tip, and result classification so a fast error never ranks as a fast answer. The candidates that failed the keyless audit are listed with their exact refusals: dRPC moved Solana to paid tiers, Ankr returns 403 without a key, OnFinality's shared public quota is permanently exhausted. + +abstract: | + Per-chain member of the RPC latency cluster and its first non-EVM + chain. We measure round-trip latency of a single identical JSON-RPC + call (getSlot at the processed commitment) against every no-key + public Solana endpoint that sustains continuous probing, 5 providers, + every 60 seconds, from us-east, eu-west and Singapore. Responses are + classified (ok / http_err / jsonrpc_err / stale / timeout) with + staleness measured in slots against the cross-provider tip. The + archive-depth audit run on EVM chains has no keyless Solana + equivalent and is not performed. The cross-chain view lives on the + parent rpc-capabilities benchmark; this page is the Solana-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 via the region tabs." + - "Payload: `{\"jsonrpc\":\"2.0\",\"id\":,\"method\":\"getSlot\",\"params\":[{\"commitment\":\"processed\"}]}`. Plain HTTP POST, identical for every endpoint, no API key in any request; the rotating id defeats body-keyed edge caches." + - "Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram, percentiles computed via Prometheus `quantile_over_time` over the last 24 hours." + - "Call-result classification: `ok`, `http_err`, `jsonrpc_err`, `stale` (more than 300 slots, about 2 minutes, behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal." + - "No archive-depth audit on Solana: the EVM chains probe `eth_getBalance` at historical heights, which has no equivalent on public Solana endpoints. Disclosed rather than faked." + - "LeoRPC disclosure: the endpoint uses a publicly documented FREE query key (solana.leorpc.com/?api_key=FREE). It is admitted as keyless in practice since no signup is required; flagged here for transparency." + - "This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; identical harness and exclusion rules." + - "Chain scope: every query on this page is pinned to chain=\"solana\". Provider coverage: 5 no-key endpoints (Solana Labs, PublicNode, Lava, LeoRPC, Solana Vibe Station). Excluded with verified refusals 2026-07-12: dRPC (Solana is paid-tier only), Ankr (403 key required), OnFinality (shared quota permanently 429), BlockPI (no public URL), Triton free.rpcpool.com (403), Blast API + ExtrNode + AllThatNode (DNS dead), OMNIA (521), Helius + Shyft + BlockEden (key-gated)." + +findings: + - "{{best_name}} currently leads free Solana RPC at {{best_p50}} (getSlot p50, 24h) across 5 measured providers." + - "{{name:solana-official}} ({{p50:solana-official}}) is the endpoint every tutorial pastes. Solana Labs documents its limits at 100 requests per 10 seconds per IP, generous for development and exactly the kind of endpoint this bench exists to sanity-check." + - "{{name:publicnode}} ({{p50:publicnode}}) extends its EVM cluster footprint to Solana from the same Allnodes infrastructure, and arrives with the credibility of leading a large share of the EVM per-chain boards." + - "{{name:lava}} ({{p50:lava}}) routes through the Lava gateway mesh, the same architecture as its Ethereum and Arbitrum endpoints; expect higher variance than single-origin providers." + - "{{name:leorpc}} ({{p50:leorpc}}) and {{name:solanavibestation}} ({{p50:solanavibestation}}) are the community tier: smaller operations whose continued keyless availability this bench monitors live rather than assumes." + +faq: + - q: "What is the fastest free Solana RPC right now?" + a: "{{best_name}} currently leads at {{best_p50}} (getSlot 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; use the region tabs to see the leader from the origin closest to your deployment." + - q: "Which Solana RPCs work without an API key?" + a: "The 5 providers on this page: Solana Labs (api.mainnet-beta.solana.com), PublicNode, Lava, LeoRPC (publicly documented FREE key) and Solana Vibe Station. Every endpoint was live-verified before inclusion. The famous names that do not work keyless anymore are listed in the methodology with their exact refusals: dRPC moved Solana to paid tiers, Ankr 403s, OnFinality's public quota is exhausted, Helius and Shyft are key-gated." + - q: "Is api.mainnet-beta.solana.com good enough for production?" + a: "For development, demos and light read workloads, yes: Solana Labs documents roughly 100 requests per 10 seconds per IP. For production trading, indexing or anything latency-sensitive, dedicated providers exist for a reason; this page measures the free tier so you know exactly what the default gets you before you decide." + - q: "How is Solana RPC latency measured here?" + a: "One identical JSON-RPC POST (getSlot at the processed commitment) every 60 seconds against each provider from each of 3 regions. Wall-clock round-trip is recorded at millisecond precision; p50/p90/p99 come from Prometheus quantile_over_time over 24 hours. Responses are classified so an endpoint stuck behind the cross-provider slot tip or erroring behind HTTP 200 is never ranked as fastest. The harness is open source." + - q: "Why is there no archive-depth column like the EVM pages?" + a: "The EVM cluster probes eth_getBalance at historical block heights to expose which free endpoints serve archive state. Public Solana endpoints expose no comparable keyless historical-state query, so the audit is disclosed as not applicable rather than approximated." + +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{provider=~"solana-official|publicnode|lava|leorpc|solanavibestation", chain="solana"}) + +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: solana-official + name: Solana Labs + tag: Chain-official api.mainnet-beta.solana.com, 100 req per 10s documented + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single `getSlot` POST sent every 60s from 3 regions (us-east + eu-west + sgp) to api.mainnet-beta.solana.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solana-official", chain="solana"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="solana-official", chain="solana"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="solana-official", chain="solana"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="solana-official", chain="solana"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="solana-official", chain="solana"}) / sum(ocb:rpc_call:rate_24h{provider="solana-official", chain="solana"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="solana-official", chain="solana"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="solana-official", chain="solana"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solana-official", chain="solana", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="solana-official", chain="solana", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solana-official", chain="solana", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="solana-official", chain="solana", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solana-official", chain="solana", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="solana-official", chain="solana", region="sgp"}[1h]) + + - slug: publicnode + name: PublicNode + tag: Allnodes-operated, same footprint as its EVM cluster entries + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single `getSlot` POST sent every 60s from 3 regions (us-east + eu-west + sgp) to solana-rpc.publicnode.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="solana"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="publicnode", chain="solana"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="publicnode", chain="solana"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="publicnode", chain="solana"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="publicnode", chain="solana"}) / sum(ocb:rpc_call:rate_24h{provider="publicnode", chain="solana"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="publicnode", chain="solana"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="solana"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="solana", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="solana", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="solana", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="solana", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="publicnode", chain="solana", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="publicnode", chain="solana", region="sgp"}[1h]) + + - slug: lava + name: Lava + tag: Gateway mesh, pooled per-IP quota + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single `getSlot` POST sent every 60s from 3 regions (us-east + eu-west + sgp) to solana.lava.build." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="solana"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="lava", chain="solana"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="lava", chain="solana"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="lava", chain="solana"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="lava", chain="solana"}) / sum(ocb:rpc_call:rate_24h{provider="lava", chain="solana"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="lava", chain="solana"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="lava", chain="solana"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="solana", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="lava", chain="solana", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="solana", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="lava", chain="solana", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="lava", chain="solana", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="lava", chain="solana", region="sgp"}[1h]) + + - slug: leorpc + name: LeoRPC + tag: Community endpoint, publicly documented FREE query key + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single `getSlot` POST sent every 60s from 3 regions (us-east + eu-west + sgp) to solana.leorpc.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="leorpc", chain="solana"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="leorpc", chain="solana"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="leorpc", chain="solana"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="leorpc", chain="solana"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="leorpc", chain="solana"}) / sum(ocb:rpc_call:rate_24h{provider="leorpc", chain="solana"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="leorpc", chain="solana"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="leorpc", chain="solana"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="leorpc", chain="solana", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="leorpc", chain="solana", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="leorpc", chain="solana", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="leorpc", chain="solana", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="leorpc", chain="solana", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="leorpc", chain="solana", region="sgp"}[1h]) + + - slug: solanavibestation + name: Solana Vibe Station + tag: Community endpoint, unpublished cap, churn monitored live + formula: "50th percentile over 24h of client-side round-trip latency (ms) for a single `getSlot` POST sent every 60s from 3 regions (us-east + eu-west + sgp) to public.rpc.solanavibestation.com." + queries: + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solanavibestation", chain="solana"}) + p90: avg(ocb:rpc_latency_milliseconds:p90_24h{provider="solanavibestation", chain="solana"}) + p99: avg(ocb:rpc_latency_milliseconds:p99_24h{provider="solanavibestation", chain="solana"}) + mean: avg(ocb:rpc_latency_milliseconds:mean_24h{provider="solanavibestation", chain="solana"}) + success: sum(ocb:rpc_call:ok_rate_24h{provider="solanavibestation", chain="solana"}) / sum(ocb:rpc_call:rate_24h{provider="solanavibestation", chain="solana"}) + sample_size: sum(ocb:rpc_call:increase_24h{provider="solanavibestation", chain="solana"}) + series: avg(avg_over_time(rpc_latency_milliseconds{provider="solanavibestation", chain="solana"}[1h])) + regions: + - region: us-east + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solanavibestation", chain="solana", region="us-east"}) + series: avg_over_time(rpc_latency_milliseconds{provider="solanavibestation", chain="solana", region="us-east"}[1h]) + - region: eu-west + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solanavibestation", chain="solana", region="eu-west"}) + series: avg_over_time(rpc_latency_milliseconds{provider="solanavibestation", chain="solana", region="eu-west"}[1h]) + - region: ap-southeast + p50: avg(ocb:rpc_latency_milliseconds:p50_24h{provider="solanavibestation", chain="solana", region="sgp"}) + series: avg_over_time(rpc_latency_milliseconds{provider="solanavibestation", chain="solana", region="sgp"}[1h]) diff --git a/harnesses/rpc-capabilities/cmd/script/archive.go b/harnesses/rpc-capabilities/cmd/script/archive.go index e4069813..8362f56b 100644 --- a/harnesses/rpc-capabilities/cmd/script/archive.go +++ b/harnesses/rpc-capabilities/cmd/script/archive.go @@ -43,6 +43,11 @@ var depthBuckets = []uint64{300, 7200, 216000, 1296000, 5000000} func StartArchiveLoop(ctx context.Context) { for _, c := range chains() { c := c + if c.Kind == "solana" { + // eth_getBalance at historical heights has no Solana + // equivalent on public endpoints; skip the archive loop. + continue + } for _, p := range c.Providers { p := p go archiveOne(ctx, c, p) diff --git a/harnesses/rpc-capabilities/cmd/script/config.go b/harnesses/rpc-capabilities/cmd/script/config.go index d23fe91d..c759b0b5 100644 --- a/harnesses/rpc-capabilities/cmd/script/config.go +++ b/harnesses/rpc-capabilities/cmd/script/config.go @@ -29,6 +29,10 @@ type Chain struct { Slug string Name string Providers []Provider + // Kind selects the probe path: "" (EVM, eth_getBlockByNumber) or + // "solana" (getSlot at processed commitment, slot-based staleness, + // no archive-depth loop). + Kind string } // chains is the source of truth for the (chain × provider) probe @@ -55,6 +59,27 @@ type Chain struct { // (3 providers), Zora / Abstract / HyperEVM (≤2 keyless providers). func chains() []Chain { return []Chain{ + // ─── Solana mainnet — added 2026-07-12, all 5 endpoints keyless + // and live-verified (getSlot + getLatestBlockhash + getVersion, + // mutually consistent advancing slots). Excluded by that sweep: + // dRPC (Solana paid-only), Ankr (403 key required), OnFinality + // (shared public quota permanently 429), BlockPI (503 no public + // URL), Blast API + ExtrNode + AllThatNode (DNS dead), Triton + // free.rpcpool.com (403), OMNIA (521), Helius/Shyft/BlockEden + // (key-gated). LeoRPC uses a publicly documented FREE query key, + // disclosed in the bench methodology. + { + Slug: "solana", + Name: "Solana", + Kind: "solana", + Providers: []Provider{ + {Slug: "solana-official", Name: "Solana Labs", URL: envDefault("RPC_URL_SOLANA_OFFICIAL", "https://api.mainnet-beta.solana.com")}, + {Slug: "publicnode", Name: "PublicNode", URL: envDefault("RPC_URL_SOLANA_PUBLICNODE", "https://solana-rpc.publicnode.com")}, + {Slug: "lava", Name: "Lava", URL: envDefault("RPC_URL_SOLANA_LAVA", "https://solana.lava.build")}, + {Slug: "leorpc", Name: "LeoRPC", URL: envDefault("RPC_URL_SOLANA_LEORPC", "https://solana.leorpc.com/?api_key=FREE")}, + {Slug: "solanavibestation", Name: "Solana Vibe Station", URL: envDefault("RPC_URL_SOLANA_SVS", "https://public.rpc.solanavibestation.com")}, + }, + }, // ─── Monad mainnet (chain 143) — added 2026-07-08, all endpoints // live-verified (eth_chainId=143 + anti-cache probe). Five official // mirrors exist behind different infra vendors; we probe the primary diff --git a/harnesses/rpc-capabilities/cmd/script/probe.go b/harnesses/rpc-capabilities/cmd/script/probe.go index 620eee81..d19f1925 100644 --- a/harnesses/rpc-capabilities/cmd/script/probe.go +++ b/harnesses/rpc-capabilities/cmd/script/probe.go @@ -26,6 +26,10 @@ const ( // cross-provider tip is classified as `stale`. 20 blocks ≈ 4 min // on Ethereum which generously covers cross-provider drift. staleBlockGap uint64 = 20 + // solanaStaleSlotGap: slots tick every ~400ms, so 300 slots is + // ~2 minutes behind the cross-provider tip - the same order of + // tolerance the EVM gap gives a 12s-block chain. + solanaStaleSlotGap uint64 = 300 ) // chainTips tracks the highest block seen for each chain across all @@ -175,12 +179,24 @@ func probeOne(ctx context.Context, c Chain, p Provider) { tick := func() { probeCtx, cancel := context.WithTimeout(ctx, probeTimeout) defer cancel() - block, result, latency, err := callLatestBlock(probeCtx, p.URL) + var block uint64 + var result string + var latency float64 + var err error + if c.Kind == "solana" { + block, result, latency, err = callLatestSlot(probeCtx, p.URL) + } else { + block, result, latency, err = callLatestBlock(probeCtx, p.URL) + } if result == "ok" { tips.update(c.Slug, block) tip := tips.get(c.Slug) - if tip > 0 && block+staleBlockGap < tip { + gap := staleBlockGap + if c.Kind == "solana" { + gap = solanaStaleSlotGap + } + if tip > 0 && block+gap < tip { result = "stale" } } @@ -227,3 +243,56 @@ func urlJitter(s string) int64 { } return sum } + +// callLatestSlot is the Solana probe path: getSlot at the processed +// commitment with a rotating request id (same anti-cache rule as the +// EVM header fetch). The result is a plain JSON number (the slot), so +// the staleness comparison reuses the chainTips machinery with slots +// in place of block numbers. +func callLatestSlot(ctx context.Context, url string) (slot uint64, result string, latencyMs float64, err error) { + body := []byte(fmt.Sprintf( + `{"jsonrpc":"2.0","method":"getSlot","params":[{"commitment":"processed"}],"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).Milliseconds()) + + 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 result") + } + n, err := strconv.ParseUint(strings.TrimSpace(string(r.Result)), 10, 64) + if err != nil { + return 0, "jsonrpc_err", latencyMs, fmt.Errorf("non-numeric slot: %s", string(r.Result)[:min(len(r.Result), 40)]) + } + return n, "ok", latencyMs, nil +} diff --git a/src/lib/removed-benches.ts b/src/lib/removed-benches.ts index 24cda458..d7823ee9 100644 --- a/src/lib/removed-benches.ts +++ b/src/lib/removed-benches.ts @@ -36,5 +36,6 @@ export const REMOVED_BENCH_SLUGS = new Set([ "indexing-freshness", "rpc-keyed-latency", "explorer-chain-coverage", + "solana-rpc", "portfolio-chain-coverage", ]);