Ship: benches 068-072, anti-cache RPC, Monad+MegaETH, keyed + indexing freshness

.github/workflows/staging-deploy.yml

@@ -46,7 +46,11 @@ jobs:
       - name: Deploy Preview
         id: deploy
         run: |
-          url=$(vercel deploy --prebuilt --token=${{ secrets.VERCEL_TOKEN }})
+          # --archive=tgz uploads ONE tarball instead of thousands of
+          # files: the team's api-upload-paid quota (40k reqs / rolling
+          # 24h) was exhausted twice on busy merge days (2026-07-06/07),
+          # blocking every deploy for hours.
+          url=$(vercel deploy --prebuilt --archive=tgz --token=${{ secrets.VERCEL_TOKEN }})
           echo "url=$url" >> "$GITHUB_OUTPUT"
           echo "Preview ready at $url"
 

alternatives/README.md

@@ -41,6 +41,7 @@ status: live                            # optional, default live
 | `bitquery` | Bitquery | network-coverage |
 | `birdeye` | Birdeye | metadata-coverage (Solana only) |
 | `relay` | Relay | bridge-quote-latency |
+| `zerion` | Zerion | portfolio-chain-coverage |
 
 ## License
 

alternatives/jupiter.yml

@@ -0,0 +1,13 @@
+slug: jupiter
+target_product: Jupiter
+target_url: https://jup.ag
+description: Solana DEX aggregator with multi-venue routing
+benchmark: solana-dex-quote-latency
+
+intro: |
+  Jupiter is a Solana DEX aggregator that routes swaps across most major venues on the network, exposing a public quote endpoint at `lite-api.jup.ag/swap/v1/quote`. Quote latency sits on the hot path of every swap a wallet, trading UI or routing front-end builds: a 600 ms response pushes a perceptible delay onto the user, while an 80 ms response feels instant. This benchmark measures the wall-clock round-trip latency of Solana DEX aggregator quote APIs every 60 seconds from three Railway regions (us-east, eu-west, sgp), against tokens that are actually trending on Solana rather than the canonical SOL to USDC pair that every provider's edge cache already memorises. The harness maintains a 30-minute sliding window of bonded tokens from Mobula Pulse V2's WebSocket feed (post-bonding-curve graduates from Pump.fun, Meteora, Raydium LaunchLab and friends), picks one at random each tick and sends an identical 100 USDC to tokenOut quote request at 1 percent slippage to each provider in parallel. The HTTP client reuses TCP and TLS connections across ticks so the recorded latency reflects steady-state cost, not a cold-start handshake. Liquidity-gap failures (a provider that cannot route the picked token) land on a separate `solana_quote_no_route_total` counter and are excluded from the latency histogram, so a provider that fails fast on long-tail coverage is not penalised on the percentiles. Histogram buckets cover 10 ms to 5 s. Providers measured alongside Jupiter are Mobula, OpenOcean and Raydium; per-region tabs at the top of the page surface where each provider's infrastructure actually sits.
+
+seo_title: "Jupiter alternatives: live benchmark"
+seo_description: Compare Jupiter against Mobula, OpenOcean and Raydium on live Solana quote latency. 100 USDC to long-tail token, polled every 60 seconds from 3 regions.
+
+status: live

alternatives/zerion.yml

@@ -0,0 +1,11 @@
+slug: zerion
+target_product: Zerion
+target_url: https://zerion.io
+description: Wallet and portfolio API for EVM chains
+benchmark: portfolio-chain-coverage
+
+intro: |
+  Zerion powers wallets and portfolio trackers with a single API for balances, positions and transactions across EVM chains. When sizing alternatives, one practical axis is chain coverage that actually works. how many chains does each portfolio API return real balances on, versus how many it lists in its own catalog? Below is the live daily probe. identical public test addresses for every provider, a chain counts once the returned balance clears $1, and the vendor's self-declared list is published next to the verified number.
+
+seo_title: "Zerion alternatives: live benchmark"
+seo_description: "Zerion alternatives on portfolio API chain coverage. Probe-verified chains vs self-declared catalogs, refreshed daily."

answers/which-evm-aggregator-has-the-fastest-quote.yml

@@ -0,0 +1,42 @@
+slug: which-evm-aggregator-has-the-fastest-quote
+question: "Which EVM swap quote API is the fastest in 2026?"
+short_answer: |
+  {{best_name}} currently returns EVM swap quotes the fastest at {{best_p50}} (p50, 24h) across Mobula, KyberSwap, Bebop, CoW, Enso, LI.FI and OpenOcean on Ethereum, Base, Arbitrum and BSC, measured live by OpenChainBench from 3 regions.
+
+benchmark: evm-quote-latency
+
+intro: |
+  EVM swap aggregator APIs all promise sub second quotes. This page measures how often they actually deliver one. Every wallet integration, intent layer and routing front end is bound by the quote API it sits behind, and the gap between a 200 ms and a 1500 ms p99 is the difference between a swap UI that feels native and one that needs a loading spinner on every input change. OpenChainBench rotates a 5 pair basket across Ethereum, Base, Arbitrum and BSC (1 ETH to USDT on Ethereum, 1000 USDC to USDT on Ethereum, 0.5 ETH to USDC on Base, 100 USDC to ETH on Arbitrum, 1 BNB to USDT on BSC), fires a quote request at every supported provider in parallel every 60 seconds, and records the wall clock round trip. The leaderboard sorts by p50 latency over the last 24 hours. A geographic split is available with the same probe running independently from us-east, eu-west and Singapore, so an integrator can pick the provider whose edge gateway is closest to their backend.
+
+methodology: |
+  Each provider's public quote endpoint is hit on the 5 fixed pairs above, rotating one pair per 60 second tick. Per (provider, chain) the bench lands roughly 288 samples in 24 hours per region, enough to put p90 and p99 buckets on a solid base. Latency is wall clock from request dispatch to last byte received, observed only on the happy path (HTTP 2xx with a parseable output amount). Failures land on dedicated counters by class (auth via 401/403, throttle via 429, no route via empty or zero output amount on 200, other for everything else) and pull the success gauge to 0. Native asset sentinel is the canonical `0xEeeeeEeee` form; Odos uses the all zero form and Bebop substitutes the wrapped equivalent on the sell side, the adapter normalises per provider. The three regions are separate Railway services writing the same metric family with a `region` label, so the page can filter to a single edge or aggregate across all three.
+
+limitations:
+  - "Speed only, quote quality is not scored. Two providers can return the same time to first byte while one quotes a noticeably worse price. Converting all outputs to a comparable USD value introduces an oracle bias the leaderboard does not want to bake into a latency ranking. The fee benchmark measures realised cost separately."
+  - "Each provider declares its supported chain set. CoW Protocol skips BSC because CoW Settlement does not deploy there; the harness skips probes for chains a provider does not claim to cover so the failure counter is not inflated by structural non coverage."
+  - "Enso uses a global anonymous bucket at roughly 1 request per second, so about 20% of probes hit 429 and are dropped. Remaining samples keep p50 and p90 stable but the success rate is capped near 80%, which the leaderboard surfaces honestly."
+  - "The 5 pair basket favours liquid USDC and ETH routes. A long tail token route (low cap memecoin, RWA, niche bridge wrapper) has different route search complexity and the latency curves on this leaderboard do not generalise to those cases."
+  - "Polygon and Optimism are slated for a v2 expansion once they reach a comparable sample volume; the current Ethereum, Base, Arbitrum and BSC coverage is the integration grade core."
+
+faq:
+  - q: "Which EVM swap quote API has the lowest latency right now?"
+    a: "{{best_name}} currently leads at {{best_p50}} (p50 over the last 24 hours) on the active tab, across {{count}} measured providers. The leaderboard re-sorts every minute on fresh Prometheus samples, so the answer reflects measured latency on the live basket, not a marketing claim. Per chain leaders can differ from the cross chain aggregate; the chain tabs at the top of the bench page show each ranking separately."
+  - q: "Does this measure quote quality or just speed?"
+    a: "Speed only. Latency is wall clock round trip from request to last byte, recorded only on a successful parseable response. Output amount in USD is not scored on this bench because providers measure it differently (Bebop is net of fees on a gasless RFQ, others are gross), and converting all outputs to a comparable USD value introduces an oracle bias the leaderboard does not want to bake into a latency comparison."
+  - q: "Why are some providers not on every chain?"
+    a: "Each provider declares its supported chain set. The harness skips probes for chains a provider does not claim to cover so the failure counter is not inflated by structural non coverage. CoW skips BSC because CoW Settlement does not deploy there; LI.FI and OpenOcean cover 30+ chains each. The per chain tab on the bench page shows which providers actually run on each chain."
+  - q: "What happens when a provider rate limits the harness?"
+    a: "Each adapter classifies the response. 429 lands on a throttle counter and the success gauge drops to 0. 401 and 403 land on an auth counter. Empty or zero output amounts on a 200 land on a no route counter. None of those failure modes contribute to the latency histogram, so the p50 number stays representative of healthy quotes."
+  - q: "How is the geographic split implemented?"
+    a: "Three identical Railway services run the harness with different `MONITOR_REGION` env vars (us-east, eu-west, sgp). Each writes the same metric family with a `region` label. The bench page region filter selects which slice of the histogram is queried; the per chain x per region grid shows a 4 chain by 3 region cell ranking for each provider."
+  - q: "Why does Bebop sometimes win on latency despite being RFQ?"
+    a: "Bebop's RFQ model resolves price through a maker network rather than via on chain simulation. The output amount it quotes is already net of fees because settlement is gasless for the taker. The latency the bench measures is the maker network resolving the price, not a public mempool route search; on liquid pairs that path can clock comparably to or below pre warmed aggregator graphs."
+
+related:
+  - which-solana-dex-aggregator-is-the-fastest
+  - which-bridge-has-the-fastest-quote-api
+  - which-crypto-price-api-is-the-fastest
+
+seo_title: "Which EVM swap quote API is the fastest in 2026?"
+seo_description: "{{best_name}} leads EVM swap quote latency at {{best_p50}} (p50, 24h) across Mobula, KyberSwap, Bebop, CoW, Enso, LI.FI and OpenOcean on Ethereum, Base, Arbitrum and BSC."
+status: live

answers/which-solana-dex-aggregator-is-the-fastest.yml

@@ -0,0 +1,42 @@
+slug: which-solana-dex-aggregator-is-the-fastest
+question: "Which Solana DEX aggregator returns the fastest swap quote?"
+short_answer: |
+  {{best_name}} currently returns Solana swap quotes the fastest at {{best_p50}} (p50, 24h) across Jupiter, Mobula, OpenOcean and Raydium on a rotating trending token basket, measured live by OpenChainBench from 3 regions.
+
+benchmark: solana-dex-quote-latency
+
+intro: |
+  Solana DEX aggregators sit on the hot path of every swap a wallet, trading UI or routing front end builds. A quote API at 80 ms feels instant to the user; a quote API at 600 ms pushes a perceptible delay between input change and updated output. Most "fastest aggregator" comparisons hardcode the canonical SOL to USDC pair, which Jupiter's lite endpoint serves from a CloudFront edge in 30 to 50 ms, measuring cache hit rather than routing. This page answers the question integrators actually need answered. Which Solana DEX aggregator returns the fastest quote when the target token is one nobody has cached, against the long tail tokens actually trending right now. OpenChainBench rotates the target every tick by picking a fresh bonded token from Mobula Pulse V2's live WebSocket feed (post bonding curve graduates from Pump.fun, Meteora, Raydium LaunchLab and friends), then fires a 100 USDC to tokenOut quote at 1% slippage against each provider in parallel from us-east, eu-west and Singapore.
+
+methodology: |
+  Every 60 seconds, in each of three Railway regions, the harness picks one Solana token from a sliding 30 minute window of bonded tokens emitted by Mobula Pulse V2 over WebSocket, then sends an identical 100 USDC to tokenOut quote (1% slippage, no fee, no referrer) to each provider. Latency is wall clock from HTTP request dispatch to the first byte of a response body containing a usable quoted output amount (Jupiter `outAmount`, Mobula `data.amountOutTokens`, OpenOcean `data.outAmount`, Raydium `data.outputAmount`). The HTTP client reuses TCP and TLS connections across ticks, so the recorded number is the steady state round trip a long lived backend integration sees, not the one off cold start handshake. Histogram buckets are 10, 25, 50, 100, 200, 500, 1000, 2000 and 5000 ms; p50, p90 and p99 are computed per region via Prometheus `histogram_quantile` over 24h. Failure classes (HTTP 429 throttled, 401/403 auth error, no route, other) each land on their own counter and are excluded from the latency histogram.
+
+limitations:
+  - "Raydium's compute API is single venue (Raydium AMM v4, CPMM, CLMM only) and does not multi hop via SOL like Jupiter or Mobula. On the Pulse fed rotation (mostly Pump.fun graduates living on PumpSwap, plus Meteora and Orca pools) Raydium returns INSUFFICIENT_LIQUIDITY on roughly 80% of picks. Its latency cells go blank below 50 successful quotes per 24h; the success rate column is its honest score."
+  - "Jupiter serves quotes from regional pods behind CloudFront (`x-region: eu-central-1` observed from EU, `x-pod-name: jupiter-core-*`), so each probe region reaches a nearby replica and its cross region spread is flat by infrastructure, not by caching. Repeated identical requests return `x-cache: Miss` every time; CloudFront does not cache this endpoint."
+  - "Quote quality (output amount, net of gas) is not scored here. Two providers can return the same time to first byte while one quotes a noticeably worse price. Converting all outputs to a comparable USD value introduces an oracle bias the leaderboard does not want to bake into a latency ranking."
+  - "Long tail token rotation defeats per pair edge caches but biases the comparison toward providers whose route engine handles fresh mints quickly. A pure SOL to USDC trader would see different absolute numbers; relative ordering on the cohort is the integration grade signal."
+  - "Direct egress from Railway, no residential proxy. The bench measures backend to backend latency as a real integration sees it; a wallet calling the API from a mobile network adds the mobile network's RTT on top."
+
+faq:
+  - q: "Which Solana DEX has the fastest quote API right now?"
+    a: "{{best_name}} currently returns quotes the fastest at {{best_p50}} (p50, 24h) across {{count}} measured providers. The leaderboard re-sorts every 60 seconds against fresh samples and rotates the target token each tick so no provider can serve from edge cache. The answer reflects 24 hours of measured latency across us-east, eu-west and Singapore."
+  - q: "What is quote latency on a DEX aggregator?"
+    a: "Quote latency is the wall clock time between a swap UI asking a DEX aggregator 'what would I get if I traded 100 USDC for this token right now' and the aggregator answering with a usable routed price. A quote API at 80 ms feels instant; a quote API at 600 ms introduces a visible delay between input change and updated output. The number sets the floor on how live a swap UI can feel before any other latency (RPC, signing, broadcast) is added."
+  - q: "Why does the bench rotate the target token instead of always quoting SOL to USDC?"
+    a: "SOL to USDC is the most cached pair on Solana. Jupiter's lite endpoint serves it from a CloudFront edge in 30 to 50 ms, but that measures cache hit, not routing. Rotating the target every tick against the tokens actually trending right now via Mobula Pulse V2's bonded WebSocket feed defeats every per pair edge cache and forces each provider to actually run a routing search. The metric becomes a fair comparison of routing engines, not CDN configurations."
+  - q: "What if a provider cannot quote a particular long tail token?"
+    a: "It is counted as a no route, not as a slow quote. Each provider has a recognisable 'I have no path for this pair' signal (Jupiter NO_ROUTES_FOUND, Mobula 'No route found', Raydium INSUFFICIENT_LIQUIDITY, OpenOcean payload level). When the harness sees it, the tick lands on `solana_quote_no_route_total` and is excluded from the latency histogram entirely, so providers that fail fast on coverage gaps are not penalised on the percentiles."
+  - q: "Why does Raydium have a much lower success rate than the aggregators?"
+    a: "Raydium's compute endpoint is single venue: it only routes against Raydium's own AMM v4, CPMM and CLMM pools and does not multi hop via SOL the way Jupiter or Mobula do. Because the rotation pulls from Mobula Pulse V2's bonded feed (most of which are Pump.fun graduates living on PumpSwap, plus Meteora and Orca), Raydium returns INSUFFICIENT_LIQUIDITY or ROUTE_NOT_FOUND on roughly 80% of picks. The Raydium latency column is the conditional p50 over the small subset of bonded tokens that happen to have a Raydium pool."
+  - q: "Are authentication errors and rate limits counted as slow?"
+    a: "No. HTTP 401, 403 and 429 responses are excluded from the latency histogram entirely. They are counted in separate counters (`solana_quote_auth_error_total`, `solana_quote_throttled_total`) which show up on the success rate column. A provider that is fast but rate limits at the configured cadence loses points on success rate, not on latency."
+
+related:
+  - which-evm-aggregator-has-the-fastest-quote
+  - which-solana-rpc-lands-the-most-transactions
+  - which-crypto-price-api-is-the-fastest
+
+seo_title: "Which Solana DEX aggregator returns the fastest swap quote in 2026?"
+seo_description: "{{best_name}} leads Solana DEX quote latency at {{best_p50}} (p50, 24h) across Jupiter, Mobula, OpenOcean and Raydium on a rotating trending token basket. Measured live by OpenChainBench from 3 regions."
+status: live