diff --git a/benchmarks/app-store-ratings.yml b/benchmarks/app-store-ratings.yml index 478c87f4..75eb14d9 100644 --- a/benchmarks/app-store-ratings.yml +++ b/benchmarks/app-store-ratings.yml @@ -70,7 +70,7 @@ metric_panels: - id: reviews label: Review count label_key: app - metric: app_store_reviews_total + metric: last_over_time(app_store_reviews_total{}[31m]) unit: count higher_is_better: true description: "Total number of user ratings submitted on the US App Store. More reviews = more statistically reliable average. Robinhood leads with 4.8M+ ratings, Coinbase follows at 1.8M+." 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/perp-fees/cmd/script/fees_test.go b/harnesses/perp-fees/cmd/script/fees_test.go new file mode 100644 index 00000000..9bad7fea --- /dev/null +++ b/harnesses/perp-fees/cmd/script/fees_test.go @@ -0,0 +1,516 @@ +package main + +import ( + "encoding/json" + "math/big" + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +// ── walkBookForNotional ──────────────────────────────────────────────────── + +func TestWalkBook_SingleLevel_ExactFill(t *testing.T) { + // One level with exactly the right notional. + // 1 ETH @ 2000 → $2000 depth. Walk $2000 → effective = 2000. + levels := []bookLevel{{Px: 2000, Sz: 1}} + eff, err := walkBookForNotional(levels, 2000) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if eff != 2000 { + t.Errorf("effective = %v, want 2000", eff) + } +} + +func TestWalkBook_MultiLevel_PartialLastLevel(t *testing.T) { + // Two ask levels; the walk must cross into the second. + // L1: 0.5 ETH @ 2000 = $1000. L2: 2 ETH @ 2010. Want: $1500 total. + // Fill L1 fully ($1000), then partial L2: $500 worth at 2010 → $500/2010 ETH. + // qty = 0.5 + $500/2010. effective = $1500 / qty. + levels := []bookLevel{ + {Px: 2000, Sz: 0.5}, + {Px: 2010, Sz: 2}, + } + eff, err := walkBookForNotional(levels, 1500) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + qty := 0.5 + 500/2010.0 + want := 1500 / qty + if abs(eff-want) > 0.001 { + t.Errorf("effective = %v, want ~%v", eff, want) + } +} + +func TestWalkBook_InsufficientDepth(t *testing.T) { + // Only $500 of depth; walk $1000 → error. + levels := []bookLevel{{Px: 2000, Sz: 0.25}} + _, err := walkBookForNotional(levels, 1000) + if err == nil { + t.Fatal("expected error for insufficient depth, got nil") + } + if !strings.Contains(err.Error(), "insufficient_depth") { + t.Errorf("error = %q, want 'insufficient_depth'", err.Error()) + } +} + +func TestWalkBook_SkipsZeroLevels(t *testing.T) { + // Zero-price and zero-size levels should be ignored. + levels := []bookLevel{ + {Px: 0, Sz: 100}, + {Px: 2000, Sz: 0}, + {Px: 2000, Sz: 1}, + } + eff, err := walkBookForNotional(levels, 1000) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if eff != 2000 { + t.Errorf("effective = %v, want 2000", eff) + } +} + +func TestWalkBook_SpreadBpsCalculation(t *testing.T) { + // bestBid=1999, bestAsk=2001, mid=2000. + // Walk $1000 at 2001 (single ask level of 10 ETH). + // effective = 2001, spread = (2001-2000)/2000*10000 = 5 bps. + mid := 2000.0 + levels := []bookLevel{{Px: 2001, Sz: 10}} + eff, err := walkBookForNotional(levels, 1000) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + spread := (eff - mid) / mid * 10000 + if abs(spread-5) > 0.001 { + t.Errorf("spread = %v bps, want 5 bps", spread) + } +} + +func TestWalkBook_99PctThreshold(t *testing.T) { + // 98% fill should fail (threshold is 99%). + levels := []bookLevel{{Px: 2000, Sz: 0.49}} // $980 of $1000 + _, err := walkBookForNotional(levels, 1000) + if err == nil { + t.Fatal("expected error for <99% fill") + } +} + +// ── walkBookForNotionalCapped ────────────────────────────────────────────── + +func TestWalkBookCapped_ThinBook_Rejected(t *testing.T) { + // Total book = $2000. Notional = $1900 (95% of book). + // maxFillRatio = 0.9 → 90% cap → $1900 > $1800 → error. + levels := []bookLevel{{Px: 2000, Sz: 1}} // $2000 total + _, err := walkBookForNotionalCapped(levels, 1900, 0.9) + if err == nil { + t.Fatal("expected error for book_too_thin") + } + if !strings.Contains(err.Error(), "book_too_thin") { + t.Errorf("error = %q, want 'book_too_thin'", err.Error()) + } +} + +func TestWalkBookCapped_AcceptableNotional(t *testing.T) { + // Total book = $2000. Notional = $1000 (50% of book). maxFillRatio=0.9 → OK. + levels := []bookLevel{{Px: 2000, Sz: 1}} + eff, err := walkBookForNotionalCapped(levels, 1000, 0.9) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if eff != 2000 { + t.Errorf("effective = %v, want 2000", eff) + } +} + +// ── totalBookNotional ────────────────────────────────────────────────────── + +func TestTotalBookNotional(t *testing.T) { + levels := []bookLevel{ + {Px: 2000, Sz: 1}, // $2000 + {Px: 2001, Sz: 2}, // $4002 + {Px: 0, Sz: 100}, // skipped + {Px: 2002, Sz: 0}, // skipped + } + want := 2000.0 + 4002.0 + got := totalBookNotional(levels) + if abs(got-want) > 0.001 { + t.Errorf("totalBookNotional = %v, want %v", got, want) + } +} + +// ── applyFlatTiers ───────────────────────────────────────────────────────── + +func TestApplyFlatTiers(t *testing.T) { + s := &PerpSample{TakerFeeBps: 6, SpreadBps: 0, AllInBps: 6} + applyFlatTiers(s) + if len(s.Tiers) != 4 { + t.Fatalf("expected 4 tiers, got %d", len(s.Tiers)) + } + for _, tier := range s.Tiers { + if tier.AllInBps != 6 { + t.Errorf("tier %s AllInBps = %v, want 6", tier.Notional, tier.AllInBps) + } + if tier.SpreadBps != 0 { + t.Errorf("tier %s SpreadBps = %v, want 0", tier.Notional, tier.SpreadBps) + } + } + labels := []string{"1000", "10000", "100000", "1000000"} + for i, tier := range s.Tiers { + if tier.Notional != labels[i] { + t.Errorf("tier[%d].Notional = %q, want %q", i, tier.Notional, labels[i]) + } + } +} + +// ── applyBookTiers: thin book skips large tiers ──────────────────────────── + +func TestApplyBookTiers_ThinBook_SkipsLargeTiers(t *testing.T) { + // Book only has $5000 depth → $10k and above tiers should be skipped. + s := &PerpSample{TakerFeeBps: 4.5} + levels := []bookLevel{{Px: 2000, Sz: 2.5}} // $5000 total + mid := 2000.0 + applyBookTiers(s, levels, mid) + // $1000 tier should succeed, $10k+ should be skipped. + if len(s.Tiers) != 1 { + t.Fatalf("expected 1 tier (only $1k), got %d tiers", len(s.Tiers)) + } + if s.Tiers[0].Notional != "1000" { + t.Errorf("tier[0].Notional = %q, want '1000'", s.Tiers[0].Notional) + } + if len(s.SkippedTiers) != 3 { + t.Errorf("expected 3 skipped tiers, got %d", len(s.SkippedTiers)) + } +} + +func TestApplyBookTiers_DeepBook_AllTiersFilled(t *testing.T) { + // Book depth $2M → all 4 tiers filled. + s := &PerpSample{TakerFeeBps: 4.5} + // Single level with 1000 ETH @ 2000 = $2M. + levels := []bookLevel{{Px: 2000, Sz: 1000}} + mid := 2000.0 + applyBookTiers(s, levels, mid) + if len(s.Tiers) != 4 { + t.Fatalf("expected 4 tiers, got %d", len(s.Tiers)) + } + if len(s.SkippedTiers) != 0 { + t.Errorf("expected 0 skipped tiers, got %v", s.SkippedTiers) + } + // All levels same price → spread = 0 at all tiers. + for _, tier := range s.Tiers { + if abs(tier.SpreadBps) > 0.001 { + t.Errorf("tier %s spread = %v bps, want 0 (uniform price)", tier.Notional, tier.SpreadBps) + } + if abs(tier.AllInBps-4.5) > 0.001 { + t.Errorf("tier %s AllInBps = %v, want 4.5", tier.Notional, tier.AllInBps) + } + } +} + +// ── factor1e30ToBps (GMX) ───────────────────────────────────────────────── + +func TestFactor1e30ToBps(t *testing.T) { + cases := []struct { + raw string + want float64 + }{ + // 6×10^26 / 10^26 = 6 bps (0.06% taker fee, typical GMX v2) + {"600000000000000000000000000", 6.0}, + // 5×10^25 / 10^26 = 0.5 bps + {"50000000000000000000000000", 0.5}, + // 1e30 / 10^26 = 10000 bps = 100% (edge, not realistic) + {"1000000000000000000000000000000", 10000.0}, + {"0", 0}, + {"", 0}, + {"not_a_number", 0}, + } + for _, c := range cases { + got := factor1e30ToBps(c.raw) + if abs(got-c.want) > 0.0001 { + t.Errorf("factor1e30ToBps(%q) = %v, want %v", c.raw, got, c.want) + } + } +} + +// ── Gains fee math ───────────────────────────────────────────────────────── + +func TestGainsFeeConversion(t *testing.T) { + // openFeeP = 350_000_000 → 350000000 / 1e8 = 3.5 bps + openFeeP := new(big.Int) + openFeeP.SetString("350000000", 10) + openFeeF, _ := new(big.Float).Quo(new(big.Float).SetInt(openFeeP), big.NewFloat(1e8)).Float64() + if abs(openFeeF-3.5) > 0.0001 { + t.Errorf("openFeeF = %v, want 3.5 bps", openFeeF) + } + + // spreadP = 100_000_000 (full spread) → half-spread = 1e8/(2×1e8) = 0.5 bps + spreadP := new(big.Int) + spreadP.SetString("100000000", 10) + spreadF, _ := new(big.Float).Quo(new(big.Float).SetInt(spreadP), big.NewFloat(2e8)).Float64() + if abs(spreadF-0.5) > 0.0001 { + t.Errorf("spreadF = %v, want 0.5 bps", spreadF) + } + + // AllIn = 3.5 + 0.5 = 4.0 + allIn := openFeeF + spreadF + if abs(allIn-4.0) > 0.0001 { + t.Errorf("allIn = %v, want 4.0 bps", allIn) + } +} + +func TestGainsSpreadPZero(t *testing.T) { + // spreadP = 0 (SOL on Gains) → half-spread = 0 bps + spreadP := big.NewInt(0) + spreadF, _ := new(big.Float).Quo(new(big.Float).SetInt(spreadP), big.NewFloat(2e8)).Float64() + if spreadF != 0 { + t.Errorf("spreadF = %v, want 0", spreadF) + } +} + +// ── HL fee math ──────────────────────────────────────────────────────────── + +func TestHLTakerFeeConversion(t *testing.T) { + // "0.00045" → 0.00045 × 10000 = 4.5 bps (default tier) + cross := 0.00045 + bps := cross * 10000 + if abs(bps-4.5) > 0.0001 { + t.Errorf("bps = %v, want 4.5", bps) + } +} + +// ── dYdX fee math ────────────────────────────────────────────────────────── + +func TestDYdXFeeConversion(t *testing.T) { + // ppm=500 → bps=5, ppm=200 → bps=2 + cases := []struct{ ppm int64; wantBps float64 }{ + {500, 5.0}, + {200, 2.0}, + {100, 1.0}, + } + for _, c := range cases { + got := float64(c.ppm) / 100.0 + if abs(got-c.wantBps) > 0.0001 { + t.Errorf("ppm=%d → %v bps, want %v", c.ppm, got, c.wantBps) + } + } +} + +// ── Paradex fee math ─────────────────────────────────────────────────────── + +func TestParadexFeeConversion(t *testing.T) { + // "0.0002" → 2 bps + rate := 0.0002 + bps := rate * 10000 + if abs(bps-2.0) > 0.0001 { + t.Errorf("bps = %v, want 2.0", bps) + } +} + +// ── Lighter fee math ─────────────────────────────────────────────────────── + +func TestLighterTakerFeeConversion(t *testing.T) { + // "0.0250" means 0.0250% → 0.0250 × 100 = 2.5 bps + takerPct := 0.0250 + bps := takerPct * 100 + if abs(bps-2.5) > 0.0001 { + t.Errorf("bps = %v, want 2.5", bps) + } +} + +// ── Mock HTTP: fetchHyperliquid ──────────────────────────────────────────── + +func TestFetchHyperliquid_MockServer(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + var req map[string]any + _ = json.NewDecoder(r.Body).Decode(&req) + w.Header().Set("Content-Type", "application/json") + switch req["type"] { + case "l2Book": + // bid 1999, ask 2001 → mid 2000 + // 10 ETH @ 2001 → $20k depth, easily fills $1000 + _ = json.NewEncoder(w).Encode(map[string]any{ + "coin": "ETH", + "levels": []any{ + // bids + []any{map[string]any{"px": "1999", "sz": "10"}}, + // asks + []any{map[string]any{"px": "2001", "sz": "10"}}, + }, + }) + case "metaAndAssetCtxs": + meta := map[string]any{"universe": []any{map[string]any{"name": "ETH"}}} + ctx := []any{map[string]any{"funding": "0.0001", "midPx": "2000"}} + _ = json.NewEncoder(w).Encode([]any{meta, ctx}) + case "userFees": + _ = json.NewEncoder(w).Encode(map[string]any{ + "feeSchedule": map[string]any{"cross": "0.00045", "add": "0.0001"}, + }) + } + })) + defer srv.Close() + + origURL := hyperliquidURL + defer func() { _ = origURL }() + + // Patch the global URL via a local test helper since the const is unexported. + // We rebuild the request manually to avoid modifying the source. + // Instead, test the math directly from the parsed values. + + // Simulate what fetchHyperliquid computes: + mid := (1999.0 + 2001.0) / 2 // 2000 + levels := []bookLevel{{Px: 2001, Sz: 10}} + eff, err := walkBookForNotional(levels, 1000) + if err != nil { + t.Fatalf("walk: %v", err) + } + spreadBps := (eff - mid) / mid * 10000 + takerBps := 0.00045 * 10000 // 4.5 bps + allIn := takerBps + spreadBps + + // spread ≈ 5 bps (2001 vs 2000 mid) + if abs(spreadBps-5) > 0.1 { + t.Errorf("spread = %v bps, want ~5", spreadBps) + } + if abs(takerBps-4.5) > 0.001 { + t.Errorf("taker = %v bps, want 4.5", takerBps) + } + if abs(allIn-9.5) > 0.1 { + t.Errorf("allIn = %v bps, want ~9.5", allIn) + } + _ = srv +} + +// ── Mock HTTP: fetchDYdX spread + fee ───────────────────────────────────── + +func TestFetchDYdX_OrderbookMustBeSorted(t *testing.T) { + // dYdX returns asks in insertion order, not sorted. The harness sorts + // before walking. Verify that without sorting the walk yields a wrong + // result, and with sorting it's correct. + // + // Unsorted asks: [2100, 2010, 2001]. Best ask is 2001 (lowest). + // If walked unsorted the first level is 2100, inflating effective price. + + unsorted := []bookLevel{ + {Px: 2100, Sz: 5}, // out-of-order + {Px: 2010, Sz: 5}, + {Px: 2001, Sz: 5}, + } + mid := 2000.0 + + effUnsorted, _ := walkBookForNotional(unsorted, 1000) + spreadUnsorted := (effUnsorted - mid) / mid * 10000 + + // Sort ascending. + sorted := []bookLevel{ + {Px: 2001, Sz: 5}, + {Px: 2010, Sz: 5}, + {Px: 2100, Sz: 5}, + } + effSorted, _ := walkBookForNotional(sorted, 1000) + spreadSorted := (effSorted - mid) / mid * 10000 + + // Sorted spread ≈ 5 bps; unsorted spread much higher. + if spreadSorted >= spreadUnsorted { + t.Errorf("sorted spread (%v) should be lower than unsorted (%v)", spreadSorted, spreadUnsorted) + } + if abs(spreadSorted-5) > 0.1 { + t.Errorf("sorted spread = %v bps, want ~5", spreadSorted) + } +} + +// ── Mock HTTP: fetchParadex thin-book cap ───────────────────────────────── + +func TestParadex_ThickTierAccepted_ThinTierSkipped(t *testing.T) { + // Paradex book: depth=100 levels, total $200k visible. + // $1k tier (0.5% of book) → accepted. + // $1M tier (500% of book) → rejected by cap. + s := &PerpSample{TakerFeeBps: 2} + levels := []bookLevel{{Px: 2000, Sz: 100}} // $200k total + mid := 2000.0 + const maxFill = 0.9 + + applyBookTiersCapped(s, levels, mid, maxFill) + + // $1000 tier: $1000 / $200000 = 0.5% < 90% → accepted. + // $10000 tier: 5% < 90% → accepted. + // $100000 tier: 50% < 90% → accepted. + // $1000000 tier: 500% > 90% → skipped. + if len(s.SkippedTiers) != 1 || s.SkippedTiers[0] != "1000000" { + t.Errorf("skipped = %v, want [1000000]", s.SkippedTiers) + } + if len(s.Tiers) != 3 { + t.Errorf("expected 3 tiers, got %d", len(s.Tiers)) + } +} + +// ── GMX: factor1e30ToBps real-world value ───────────────────────────────── + +func TestGMX_NegativeImpactFactor_RealisticValue(t *testing.T) { + // GMX v2 ETH market on Arbitrum. The on-chain positionFeeFactorForNegativeImpact + // is typically ~6×10^26 (6 bps). Verify the conversion is stable. + raw := "600000000000000000000000000" + got := factor1e30ToBps(raw) + if abs(got-6.0) > 0.0001 { + t.Errorf("factor1e30ToBps(%q) = %v, want 6.0 bps", raw, got) + } + // AllIn: no spread on GMX (oracle), so allIn = takerBps. + allIn := got + 0.0 // SpreadBps = 0 + if abs(allIn-6.0) > 0.0001 { + t.Errorf("GMX allIn = %v bps, want 6.0", allIn) + } +} + +// ── notionalLabel ───────────────────────────────────────────────────────── + +func TestNotionalLabel(t *testing.T) { + cases := []struct{ n float64; want string }{ + {1000, "1000"}, + {10000, "10000"}, + {100000, "100000"}, + {1000000, "1000000"}, + } + for _, c := range cases { + got := notionalLabel(c.n) + if got != c.want { + t.Errorf("notionalLabel(%v) = %q, want %q", c.n, got, c.want) + } + } +} + +// ── uint256ArgAt (Gains on-chain parsing) ───────────────────────────────── + +func TestUint256ArgAt(t *testing.T) { + // Slot 0: 0x...0000000000000000000000000000000000000000000000000000000000000020 (32) + // Slot 1: 0x...0000000000000000000000000000000000000000000000000000000000000003 (3) + result := "0x" + + "0000000000000000000000000000000000000000000000000000000000000020" + + "0000000000000000000000000000000000000000000000000000000000000003" + + got0 := uint256ArgAt(result, 0) + if got0.Cmp(big.NewInt(0x20)) != 0 { + t.Errorf("slot 0 = %v, want 32", got0) + } + got1 := uint256ArgAt(result, 1) + if got1.Cmp(big.NewInt(3)) != 0 { + t.Errorf("slot 1 = %v, want 3", got1) + } +} + +func TestUint256ArgAt_OutOfBounds(t *testing.T) { + result := "0x" + "0000000000000000000000000000000000000000000000000000000000000001" + // Slot 5 doesn't exist; should return 0. + got := uint256ArgAt(result, 5) + if got.Cmp(big.NewInt(0)) != 0 { + t.Errorf("out-of-bounds slot returned %v, want 0", got) + } +} + +// ── helpers ──────────────────────────────────────────────────────────────── + +func abs(x float64) float64 { + if x < 0 { + return -x + } + return x +} 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/package.json b/package.json index 1b9d4d1f..bac59617 100644 --- a/package.json +++ b/package.json @@ -31,6 +31,7 @@ "gray-matter": "^4.0.3", "html-to-image": "^1.11.13", "ioredis": "^5.11.1", + "js-sha3": "^0.13.0", "js-yaml": "^4.3.0", "lucide-react": "^1.11.0", "mcp-handler": "^1.1.0", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 65f601a1..87d47e36 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -35,6 +35,9 @@ importers: ioredis: specifier: ^5.11.1 version: 5.11.1 + js-sha3: + specifier: ^0.13.0 + version: 0.13.0 js-yaml: specifier: ^4.3.0 version: 4.3.0 @@ -2294,6 +2297,9 @@ packages: jose@6.2.4: resolution: {integrity: sha512-N8acGzVsQy6M/fjFcxtysNc4Q379TcM5dM/qKkNtsHFji88yANnXTr7BLeP75iPnFwBfQzM/jg2BZ9+HZrHCZA==} + js-sha3@0.13.0: + resolution: {integrity: sha512-v2qy9Guw8XMOYFauObtG1kXLfut7AcSRgBP2rq4R14gVFAO2fW5kjcHcPWkA2IUDbY0cGGZypDMUuP/kkbvNGw==} + js-tokens@4.0.0: resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} @@ -5702,6 +5708,8 @@ snapshots: jose@6.2.4: {} + js-sha3@0.13.0: {} + js-tokens@4.0.0: {} js-yaml@3.15.0: 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/app/api/fee-compare/route.ts b/src/app/api/fee-compare/route.ts new file mode 100644 index 00000000..00f6cd79 --- /dev/null +++ b/src/app/api/fee-compare/route.ts @@ -0,0 +1,836 @@ +import { NextResponse } from "next/server"; +import { clientKey, rateLimit, tooManyRequests } from "@/lib/rate-limit"; +import { keccak256 } from "js-sha3"; + +export const runtime = "nodejs"; +export const maxDuration = 30; + +const HL_API = "https://api.hyperliquid.xyz/info"; +const ARB_RPC = "https://arb1.arbitrum.io/rpc"; +const GAINS_DIAMOND_ARB = "0xFF162c694eAA571f685030649814282eA457f169"; +const GAINS_VARS_URL = "https://backend-arbitrum.gains.trade/trading-variables"; +const FEES_PROCESSED_TOPIC = + "0x71555a7cc983000fe069574303ed2e47aa16417d297441f6d5e314bd6c58b2fe"; +const GMX_SUBSQUID = "https://gmx.squids.live/gmx-synthetics-arbitrum:prod/api/graphql"; +const DYDX_INDEXER = "https://indexer.dydx.trade"; + +const GAINS_FEE_PRECISION = 1e12; +const HL_TAKER_FALLBACK = 0.00035; + +const WALLET_RE = /^0x[0-9a-fA-F]{40}$/; +const DYDX_ADDRESS_RE = /^dydx1[a-z0-9]{38}$/; +const BLOCKS_PER_DAY = 43200; +const MAX_DISPLAY_FILLS = 50; +const RATE_CACHE_TTL_MS = 60 * 60 * 1000; + +const VENUE_NAMES: Record = { + hyperliquid: "Hyperliquid", + gains: "Gains", + dydx: "dYdX v4", + "gmx-v2": "GMX v2", + paradex: "Paradex", + edgex: "EdgeX", +}; + +const VALID_SLUGS = new Set(Object.keys(VENUE_NAMES)); +const EVM_WALLET_VENUES = new Set(["hyperliquid", "gains", "gmx-v2"]); + +// ────────────────────────────────────────────────────────────────────── +// Rate caches +// ────────────────────────────────────────────────────────────────────── + +let gainsFeeCache: { + coinRoundTrip: Record; + perSide: Record; + avgPerSide: number; + ts: number; +} | null = null; + +type RateCacheEntry = { rate: number; note: string; ts: number }; +const rateCache: Partial> = {}; + +// ────────────────────────────────────────────────────────────────────── +// Types +// ────────────────────────────────────────────────────────────────────── + +type HlFill = { + coin: string; + px: string; + sz: string; + fee: string; + time: number; + dir: string; + side: string; + closedPnl: string; + crossed: boolean; +}; + +type HlFundingEvent = { + time: number; + delta: { usdc: string }; +}; + +type GainsLog = { + topics: string[]; + data: string; + blockNumber: string; + transactionHash: string; +}; + +type GainsTradingVars = { + pairs: Array<{ from: string; feeIndex: string }>; + fees: Array<{ totalPositionSizeFeeP: string }>; +}; + +type HlWalletData = { + fills: number; + notionalUsd: number; + feesUsd: number; + fundingUsd: number; + netCostUsd: number; + avgFeeRateBps: number; + topCoins: Array<{ coin: string; fills: number; notional: number; fees: number }>; + recentFills: Array<{ + time: number; + coin: string; + dir: string; + side: string; + notional: number; + hlFee: number; + equivFee?: number; + closedPnl: number; + isTaker: boolean; + }>; +}; + +type GainsWalletData = { + events: number; + feesUsdc: number; + positionSizeUsdc: number; + avgFeeRateBps: number; +}; + +type GmxWalletData = { + trades: number; + feesUsdc: number; + notionalUsd: number; + avgFeeRateBps: number; +}; + +type DydxWalletData = { + fills: number; + feesUsdc: number; + notionalUsd: number; + avgFeeRateBps: number; +}; + +type AnyWallet = HlWalletData | GainsWalletData | GmxWalletData | DydxWalletData; + +type VenueResult = { + slug: string; + name: string; + ratePerAction: number; + rateBps: number; + rateNote: string; + rateIsLive: boolean; + wallet: AnyWallet | null; + effectiveRateBps?: number; + effectiveRateNote?: string; +}; + +type SimResult = { + notionalUsed: number; + feesActual: number; + equivFees: number; + saved: number; + multiple: number | null; + fundingUsd?: number; +}; + +type ComparisonResult = { + aToBSim: SimResult | null; + bToASim: SimResult | null; +}; + +// ────────────────────────────────────────────────────────────────────── +// Fetch helpers +// ────────────────────────────────────────────────────────────────────── + +async function fetchGainsFeeRates(): Promise<{ + coinRoundTrip: Record; + perSide: Record; + avgPerSide: number; +}> { + const now = Date.now(); + if (gainsFeeCache && now - gainsFeeCache.ts < RATE_CACHE_TTL_MS) { + return { + coinRoundTrip: gainsFeeCache.coinRoundTrip, + perSide: gainsFeeCache.perSide, + avgPerSide: gainsFeeCache.avgPerSide, + }; + } + const res = await fetch(GAINS_VARS_URL, { + signal: AbortSignal.timeout(8000), + next: { revalidate: 3600 }, + }); + const vars = (await res.json()) as GainsTradingVars; + const coinRoundTrip: Record = {}; + const perSide: Record = {}; + for (const p of vars.pairs) { + if (coinRoundTrip[p.from]) continue; + const fi = parseInt(p.feeIndex, 10); + const entry = vars.fees[fi]; + if (!entry) continue; + const ps = parseInt(entry.totalPositionSizeFeeP, 10) / GAINS_FEE_PRECISION; + coinRoundTrip[p.from] = ps * 2; + perSide[p.from] = ps; + } + const sides = Object.values(perSide); + const avgPerSide = + sides.length > 0 ? sides.reduce((a, b) => a + b, 0) / sides.length : 0.0005; + gainsFeeCache = { coinRoundTrip, perSide, avgPerSide, ts: now }; + return { coinRoundTrip, perSide, avgPerSide }; +} + +async function fetchHlRate(): Promise<{ rate: number; note: string }> { + const cached = rateCache["hyperliquid"]; + if (cached && Date.now() - cached.ts < RATE_CACHE_TTL_MS) return cached; + const res = await fetch(HL_API, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ type: "userFees", user: "0x0000000000000000000000000000000000000000" }), + signal: AbortSignal.timeout(8000), + }); + const data = (await res.json()) as { userCrossRate?: string }; + const rate = parseFloat(data.userCrossRate ?? String(HL_TAKER_FALLBACK)); + const entry = { rate, note: `${(rate * 10000).toFixed(2)} bps taker (live from HL fee schedule)`, ts: Date.now() }; + rateCache["hyperliquid"] = entry; + return entry; +} + +async function fetchParadexRate(): Promise<{ rate: number; note: string }> { + const cached = rateCache["paradex"]; + if (cached && Date.now() - cached.ts < RATE_CACHE_TTL_MS) return cached; + const res = await fetch("https://api.prod.paradex.trade/v1/markets?market=BTC-USD-PERP", { + signal: AbortSignal.timeout(8000), + }); + const data = (await res.json()) as { + results?: Array<{ fee_config?: { api_fee?: { taker_fee?: { fee?: string } } } }>; + }; + const rawRate = data.results?.[0]?.fee_config?.api_fee?.taker_fee?.fee ?? "0.0002"; + const rate = parseFloat(rawRate); + const entry = { rate, note: `${(rate * 10000).toFixed(2)} bps taker (live from Paradex)`, ts: Date.now() }; + rateCache["paradex"] = entry; + return entry; +} + +async function fetchEdgeXRate(): Promise<{ rate: number; note: string }> { + const cached = rateCache["edgex"]; + if (cached && Date.now() - cached.ts < RATE_CACHE_TTL_MS) return cached; + const res = await fetch("https://edgex-prod-v2.edgex.exchange/api/v2/public/meta/getMetaData", { + signal: AbortSignal.timeout(8000), + }); + const data = (await res.json()) as { + data?: { contractList?: Array<{ defaultTakerFeeRate?: string | number }> }; + }; + const contracts = data.data?.contractList ?? []; + const rates = contracts.map((c) => parseFloat(String(c.defaultTakerFeeRate ?? "0"))).filter((r) => r > 0); + const rate = rates.length > 0 ? rates.reduce((a, b) => a + b, 0) / rates.length : 0.00038; + const entry = { rate, note: `${(rate * 10000).toFixed(2)} bps taker (live from EdgeX)`, ts: Date.now() }; + rateCache["edgex"] = entry; + return entry; +} + +async function fetchGmxLiveRate(): Promise<{ rate: number; note: string }> { + const cached = rateCache["gmx-v2"]; + if (cached && Date.now() - cached.ts < RATE_CACHE_TTL_MS) return cached; + // Filter to USDC-collateral only: other tokens have different decimals, + // making positionFeeAmount/1e6 astronomically wrong. + const query = `{ + tradeActions( + where: { + positionFeeAmount_isNull: false + sizeDeltaUsd_gt: "0" + orderType_in: [2, 3, 4] + initialCollateralTokenAddress_in: [ + "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", + "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8" + ] + } + orderBy: timestamp_DESC + limit: 50 + ) { sizeDeltaUsd positionFeeAmount } + }`; + const res = await fetch(GMX_SUBSQUID, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ query }), + signal: AbortSignal.timeout(10000), + }); + const body = (await res.json()) as { + data?: { tradeActions: Array<{ sizeDeltaUsd: string; positionFeeAmount: string }> }; + }; + const trades = body.data?.tradeActions ?? []; + let totalFees = 0; + let totalNotional = 0; + for (const t of trades) { + totalFees += Number(BigInt(t.positionFeeAmount)) / 1e6; + totalNotional += Number(BigInt(t.sizeDeltaUsd) / BigInt("1000000000000000000000000")) / 1e6; + } + const rate = totalNotional > 0 ? totalFees / totalNotional : 0.0005; + const entry = { rate, note: `${(rate * 10000).toFixed(2)} bps (live avg from recent GMX v2 trades)`, ts: Date.now() }; + rateCache["gmx-v2"] = entry; + return entry; +} + +async function resolveRate(slug: string): Promise<{ rate: number; note: string; rateIsLive: boolean }> { + if (slug === "gains") { + const d = await fetchGainsFeeRates(); + return { rate: d.avgPerSide, note: "Live per-coin taker rate (avg across pairs)", rateIsLive: true }; + } + if (slug === "hyperliquid") { + const r = await fetchHlRate().catch(() => ({ rate: HL_TAKER_FALLBACK, note: "3.50 bps taker (HL base tier)" })); + return { ...r, rateIsLive: true }; + } + if (slug === "paradex") { + const r = await fetchParadexRate().catch(() => ({ rate: 0.0002, note: "2.00 bps taker (Paradex api-tier)" })); + return { ...r, rateIsLive: true }; + } + if (slug === "edgex") { + const r = await fetchEdgeXRate().catch(() => ({ rate: 0.00038, note: "3.80 bps taker (EdgeX)" })); + return { ...r, rateIsLive: true }; + } + if (slug === "gmx-v2") { + const r = await fetchGmxLiveRate().catch(() => ({ rate: 0.0005, note: "5.00 bps taker (GMX v2 fallback)" })); + return { ...r, rateIsLive: true }; + } + if (slug === "dydx") return { rate: 0.0005, note: "5.00 bps taker (tier-0, protocol-governed)", rateIsLive: false }; + return { rate: 0.0005, note: "Documented rate", rateIsLive: false }; +} + +async function rpcCall(method: string, params: unknown[]): Promise { + const res = await fetch(ARB_RPC, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }), + signal: AbortSignal.timeout(15000), + }); + const d = (await res.json()) as { result?: unknown; error?: { message: string } }; + if (d.error) throw new Error(`RPC ${method}: ${d.error.message}`); + return d.result; +} + +async function getLatestBlock(): Promise { + const hex = (await rpcCall("eth_blockNumber", [])) as string; + return parseInt(hex, 16); +} + +async function fetchGainsLogs(wallet: string, fromBlock: number, toBlock: number) { + const walletPadded = + "0x" + wallet.replace("0x", "").toLowerCase().padStart(64, "0"); + const logs = (await rpcCall("eth_getLogs", [ + { + address: GAINS_DIAMOND_ARB, + topics: [FEES_PROCESSED_TOPIC, null, walletPadded], + fromBlock: "0x" + fromBlock.toString(16), + toBlock: "0x" + toBlock.toString(16), + }, + ])) as GainsLog[]; + + return logs + .map((log) => { + const collateralIndex = parseInt(log.topics[1] ?? "0x0", 16); + const data = log.data.replace("0x", ""); + if (data.length < 192) return null; + const posSize = BigInt("0x" + data.slice(0, 64)); + const orderType = parseInt(data.slice(64, 128), 16); + const totalFees = BigInt("0x" + data.slice(128, 192)); + return { collateralIndex, orderType, posSize, totalFees }; + }) + .filter(Boolean) as Array<{ + collateralIndex: number; + orderType: number; + posSize: bigint; + totalFees: bigint; + }>; +} + +async function fetchHlFills(wallet: string): Promise { + const res = await fetch(HL_API, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ type: "userFills", user: wallet }), + signal: AbortSignal.timeout(15000), + }); + const data = await res.json(); + return Array.isArray(data) ? (data as HlFill[]) : []; +} + +async function fetchHlFunding(wallet: string, startMs: number): Promise { + const res = await fetch(HL_API, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ type: "userFunding", user: wallet, startTime: startMs }), + signal: AbortSignal.timeout(15000), + }); + const data = await res.json(); + return Array.isArray(data) ? (data as HlFundingEvent[]) : []; +} + +async function fetchGmxTrades(wallet: string): Promise { + const query = ` + query GmxTrades($account: String!) { + tradeActions( + where: { + account_eq: $account + positionFeeAmount_isNull: false + sizeDeltaUsd_gt: "0" + orderType_in: [2, 3, 4] + initialCollateralTokenAddress_in: [ + "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", + "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8" + ] + } + orderBy: timestamp_DESC + limit: 200 + ) { + sizeDeltaUsd + positionFeeAmount + orderType + } + } + `; + const res = await fetch(GMX_SUBSQUID, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ query, variables: { account: toChecksumAddress(wallet) } }), + signal: AbortSignal.timeout(15000), + }); + if (!res.ok) throw new Error(`GMX Subsquid ${res.status}`); + const body = (await res.json()) as { + data?: { + tradeActions: Array<{ + sizeDeltaUsd: string; + positionFeeAmount: string; + orderType: number; + }>; + }; + }; + const trades = body.data?.tradeActions ?? []; + + let feesUsdc = 0; + let notionalUsd = 0; + for (const t of trades) { + feesUsdc += Number(BigInt(t.positionFeeAmount)) / 1e6; + // sizeDeltaUsd has 30 decimals; divide by 1e24 to get 6-decimal USD, then /1e6 + notionalUsd += + Number(BigInt(t.sizeDeltaUsd) / BigInt("1000000000000000000000000")) / 1e6; + } + + return { + trades: trades.length, + feesUsdc, + notionalUsd, + avgFeeRateBps: notionalUsd > 0 ? (feesUsdc / notionalUsd) * 10000 : 0, + }; +} + +async function fetchDydxFills(dydxAddress: string): Promise { + const res = await fetch( + `${DYDX_INDEXER}/v4/fills?address=${encodeURIComponent(dydxAddress)}&subaccountNumber=0&limit=100`, + { signal: AbortSignal.timeout(10000) } + ); + if (!res.ok) throw new Error(`dYdX indexer ${res.status}`); + const body = (await res.json()) as { + fills?: Array<{ fee: string; price: string; size: string; liquidity?: string }>; + }; + // Keep only taker fills (positive fee) + const fills = (body.fills ?? []).filter((f) => parseFloat(f.fee) > 0); + + let feesUsdc = 0; + let notionalUsd = 0; + for (const f of fills) { + feesUsdc += parseFloat(f.fee); + notionalUsd += parseFloat(f.price) * parseFloat(f.size); + } + + return { + fills: fills.length, + feesUsdc, + notionalUsd, + avgFeeRateBps: notionalUsd > 0 ? (feesUsdc / notionalUsd) * 10000 : 0, + }; +} + +function buildHlWalletData( + recentFills: HlFill[], + hlFundingTotal: number +): HlWalletData { + let hlNotional = 0; + let hlFees = 0; + const coinMap: Record = {}; + + for (const f of recentFills) { + const notional = parseFloat(f.px) * parseFloat(f.sz); + const fee = parseFloat(f.fee); + hlNotional += notional; + hlFees += fee; + if (!coinMap[f.coin]) coinMap[f.coin] = { fills: 0, notional: 0, fees: 0 }; + coinMap[f.coin].fills++; + coinMap[f.coin].notional += notional; + coinMap[f.coin].fees += fee; + } + + const topCoins = Object.entries(coinMap) + .sort((a, b) => b[1].notional - a[1].notional) + .slice(0, 5) + .map(([coin, d]) => ({ coin, ...d })); + + const displayFills = recentFills + .slice() + .sort((a, b) => b.time - a.time) + .slice(0, MAX_DISPLAY_FILLS) + .map((f) => ({ + time: f.time, + coin: f.coin, + dir: f.dir, + side: f.side, + notional: parseFloat(f.px) * parseFloat(f.sz), + hlFee: parseFloat(f.fee), + closedPnl: parseFloat(f.closedPnl), + isTaker: f.crossed, + })); + + return { + fills: recentFills.length, + notionalUsd: hlNotional, + feesUsd: hlFees, + fundingUsd: hlFundingTotal, + netCostUsd: hlFees - hlFundingTotal, + avgFeeRateBps: hlNotional > 0 ? (hlFees / hlNotional) * 10000 : 0, + topCoins, + recentFills: displayFills, + }; +} + +// EIP-55 checksum — Subsquid stores addresses in checksummed format +function toChecksumAddress(address: string): string { + const lower = address.toLowerCase().replace("0x", ""); + const hash = keccak256(lower); + const result = lower + .split("") + .map((c, i) => (parseInt(hash[i], 16) >= 8 ? c.toUpperCase() : c)) + .join(""); + return "0x" + result; +} + +function walletStats(slug: string, w: AnyWallet): { notional: number; fees: number } | null { + if (slug === "hyperliquid") { + const x = w as HlWalletData; + return x.fills > 0 ? { notional: x.notionalUsd, fees: x.feesUsd } : null; + } + if (slug === "gains") { + const x = w as GainsWalletData; + return x.events > 0 ? { notional: x.positionSizeUsdc, fees: x.feesUsdc } : null; + } + if (slug === "gmx-v2") { + const x = w as GmxWalletData; + return x.trades > 0 ? { notional: x.notionalUsd, fees: x.feesUsdc } : null; + } + if (slug === "dydx") { + const x = w as DydxWalletData; + return x.fills > 0 ? { notional: x.notionalUsd, fees: x.feesUsdc } : null; + } + return null; +} + +// ────────────────────────────────────────────────────────────────────── +// Route +// ────────────────────────────────────────────────────────────────────── + +export async function GET(req: Request) { + const rl = rateLimit(clientKey(req, "fee-compare"), 5, 60); + if (!rl.ok) return tooManyRequests(rl.retryAfterSec); + + const url = new URL(req.url); + const wallet = url.searchParams.get("wallet")?.trim() ?? ""; + const dydxAddress = url.searchParams.get("dydxAddress")?.trim() ?? ""; + const rawNotional = parseFloat(url.searchParams.get("notional") ?? "0"); + const simNotional = isFinite(rawNotional) && rawNotional > 0 ? Math.min(rawNotional, 1e9) : 0; + const days = Math.min( + 180, + Math.max(7, parseInt(url.searchParams.get("days") ?? "90", 10)) + ); + const venueA = (url.searchParams.get("venueA") ?? "hyperliquid").toLowerCase(); + const venueB = (url.searchParams.get("venueB") ?? "gains").toLowerCase(); + + if (!VALID_SLUGS.has(venueA) || !VALID_SLUGS.has(venueB)) { + return NextResponse.json({ error: "invalid_venue" }, { status: 400 }); + } + if (venueA === venueB) { + return NextResponse.json({ error: "same_venue" }, { status: 400 }); + } + if (dydxAddress && !DYDX_ADDRESS_RE.test(dydxAddress)) { + return NextResponse.json({ error: "invalid_dydx_address" }, { status: 400 }); + } + + const walletProvided = WALLET_RE.test(wallet); + const dydxProvided = DYDX_ADDRESS_RE.test(dydxAddress); + const needsEvmWallet = EVM_WALLET_VENUES.has(venueA) || EVM_WALLET_VENUES.has(venueB); + const needsDydx = venueA === "dydx" || venueB === "dydx"; + const fetchEvmWallet = walletProvided && needsEvmWallet; + const fetchDydxWallet = dydxProvided && needsDydx; + + const cutoffMs = Date.now() - days * 86400 * 1000; + + try { + const [ + { rate: rateA, note: noteA, rateIsLive: rateIsLiveA }, + { rate: rateB, note: noteB, rateIsLive: rateIsLiveB }, + gainsData, + ] = await Promise.all([ + resolveRate(venueA), + resolveRate(venueB), + fetchGainsFeeRates(), + ]); + + let hlFillsData: HlFill[] = []; + let hlFundingData: HlFundingEvent[] = []; + let gainsLogsData: Array<{ + collateralIndex: number; + orderType: number; + posSize: bigint; + totalFees: bigint; + }> = []; + let gmxWalletData: GmxWalletData | null = null; + let dydxWalletData: DydxWalletData | null = null; + + const fetches: Promise[] = []; + + if (fetchEvmWallet) { + if (venueA === "hyperliquid" || venueB === "hyperliquid") { + fetches.push( + fetchHlFills(wallet).then((f) => { + hlFillsData = f; + }), + fetchHlFunding(wallet, cutoffMs).then((f) => { + hlFundingData = f; + }) + ); + } + if (venueA === "gains" || venueB === "gains") { + fetches.push( + getLatestBlock().then(async (latestBlock) => { + const fromBlock = Math.max( + 0, + latestBlock - Math.ceil(days * BLOCKS_PER_DAY) + ); + gainsLogsData = await fetchGainsLogs(wallet, fromBlock, latestBlock); + }) + ); + } + if (venueA === "gmx-v2" || venueB === "gmx-v2") { + fetches.push( + fetchGmxTrades(wallet) + .then((d) => { + gmxWalletData = d; + }) + .catch(() => {}) + ); + } + } + + if (fetchDydxWallet) { + fetches.push( + fetchDydxFills(dydxAddress) + .then((d) => { + dydxWalletData = d; + }) + .catch(() => {}) + ); + } + + await Promise.all(fetches); + + function buildVenueResult(slug: string, rate: number, note: string, rateIsLive: boolean): VenueResult { + let walletData: AnyWallet | null = null; + + if (fetchEvmWallet && slug === "hyperliquid") { + const recentFills = hlFillsData.filter((f) => f.time >= cutoffMs); + const recentFunding = hlFundingData.filter((f) => f.time >= cutoffMs); + const fundingTotal = recentFunding.reduce( + (s, f) => s + parseFloat(f.delta?.usdc ?? "0"), + 0 + ); + walletData = buildHlWalletData(recentFills, fundingTotal); + // Annotate each fill with the equivalent fee on the other venue + const otherSlug = slug === venueA ? venueB : venueA; + const otherRate = slug === venueA ? rateB : rateA; + const hlW = walletData as HlWalletData; + hlW.recentFills = hlW.recentFills.map((fill) => ({ + ...fill, + equivFee: otherSlug === "gains" + ? fill.notional * (gainsData.perSide[fill.coin] ?? gainsData.avgPerSide) + : fill.notional * otherRate, + })); + } else if (fetchEvmWallet && slug === "gains") { + const usdcLogs = gainsLogsData.filter((l) => l.collateralIndex === 3); + const feesUsdc = usdcLogs.reduce( + (s, l) => s + Number(l.totalFees) / 1e6, + 0 + ); + const sizeUsdc = usdcLogs.reduce( + (s, l) => s + Number(l.posSize) / 1e6, + 0 + ); + const gd: GainsWalletData = { + events: usdcLogs.length, + feesUsdc, + positionSizeUsdc: sizeUsdc, + avgFeeRateBps: sizeUsdc > 0 ? (feesUsdc / sizeUsdc) * 10000 : 0, + }; + walletData = gd; + } else if (fetchEvmWallet && slug === "gmx-v2" && gmxWalletData) { + walletData = gmxWalletData; + } else if (fetchDydxWallet && slug === "dydx" && dydxWalletData) { + walletData = dydxWalletData; + } + + return { + slug, + name: VENUE_NAMES[slug] ?? slug, + ratePerAction: rate, + rateBps: rate * 10000, + rateNote: note, + rateIsLive, + wallet: walletData, + }; + } + + const venueAResult = buildVenueResult(venueA, rateA, noteA, rateIsLiveA); + const venueBResult = buildVenueResult(venueB, rateB, noteB, rateIsLiveB); + + const comparison: ComparisonResult = { aToBSim: null, bToASim: null }; + + // aToBSim: venueA actual fills vs simulated venueB cost + if (venueAResult.wallet !== null) { + if (venueA === "hyperliquid" && venueB === "gains") { + // Per-coin Gains rates on HL fills + const hlW = venueAResult.wallet as HlWalletData; + if (hlW.fills > 0) { + let bEquiv = 0, aNotional = 0, aFees = 0; + for (const fill of hlFillsData.filter((f) => f.time >= cutoffMs)) { + const notional = parseFloat(fill.px) * parseFloat(fill.sz); + const fee = parseFloat(fill.fee); + const coinRate = gainsData.perSide[fill.coin] ?? gainsData.avgPerSide; + bEquiv += notional * coinRate; + aNotional += notional; + aFees += fee; + } + comparison.aToBSim = { + notionalUsed: aNotional, + feesActual: aFees, + equivFees: bEquiv, + saved: bEquiv - aFees, + multiple: aFees > 0 ? bEquiv / aFees : null, + fundingUsd: (venueAResult.wallet as HlWalletData).fundingUsd, + }; + if (aNotional > 0) { + venueAResult.effectiveRateBps = (aFees / aNotional) * 10000; + venueAResult.effectiveRateNote = `${((aFees / aNotional) * 10000).toFixed(2)} bps actual (your fills)`; + venueBResult.effectiveRateBps = (bEquiv / aNotional) * 10000; + venueBResult.effectiveRateNote = `${((bEquiv / aNotional) * 10000).toFixed(2)} bps effective (your coins)`; + } + } + } else { + const stats = walletStats(venueA, venueAResult.wallet); + if (stats) { + const equivFees = stats.notional * rateB; + comparison.aToBSim = { + notionalUsed: stats.notional, + feesActual: stats.fees, + equivFees, + saved: equivFees - stats.fees, + multiple: stats.fees > 0 ? equivFees / stats.fees : null, + }; + if (stats.notional > 0) { + venueAResult.effectiveRateBps = (stats.fees / stats.notional) * 10000; + venueAResult.effectiveRateNote = `${((stats.fees / stats.notional) * 10000).toFixed(2)} bps actual (your fills)`; + venueBResult.effectiveRateBps = rateB * 10000; + } + } + } + } + + // bToASim: venueB actual fills vs simulated venueA cost + if (venueBResult.wallet !== null) { + if (venueB === "hyperliquid" && venueA === "gains") { + const hlW = venueBResult.wallet as HlWalletData; + if (hlW.fills > 0) { + let aEquiv = 0, bNotional = 0, bFees = 0; + for (const fill of hlFillsData.filter((f) => f.time >= cutoffMs)) { + const notional = parseFloat(fill.px) * parseFloat(fill.sz); + const fee = parseFloat(fill.fee); + const coinRate = gainsData.perSide[fill.coin] ?? gainsData.avgPerSide; + aEquiv += notional * coinRate; + bNotional += notional; + bFees += fee; + } + comparison.bToASim = { + notionalUsed: bNotional, + feesActual: bFees, + equivFees: aEquiv, + saved: bFees - aEquiv, + multiple: bFees > 0 ? aEquiv / bFees : null, + fundingUsd: (venueBResult.wallet as HlWalletData).fundingUsd, + }; + if (bNotional > 0) { + venueBResult.effectiveRateBps = (bFees / bNotional) * 10000; + venueBResult.effectiveRateNote = `${((bFees / bNotional) * 10000).toFixed(2)} bps actual (your fills)`; + venueAResult.effectiveRateBps = (aEquiv / bNotional) * 10000; + venueAResult.effectiveRateNote = `${((aEquiv / bNotional) * 10000).toFixed(2)} bps effective (your coins)`; + } + } + } else { + const stats = walletStats(venueB, venueBResult.wallet); + if (stats) { + const equivFees = stats.notional * rateA; + comparison.bToASim = { + notionalUsed: stats.notional, + feesActual: stats.fees, + equivFees, + saved: stats.fees - equivFees, + multiple: stats.fees > 0 ? equivFees / stats.fees : null, + }; + if (stats.notional > 0) { + venueBResult.effectiveRateBps = (stats.fees / stats.notional) * 10000; + venueBResult.effectiveRateNote = `${((stats.fees / stats.notional) * 10000).toFixed(2)} bps actual (your fills)`; + venueAResult.effectiveRateBps = rateA * 10000; + } + } + } + } + + const simulated = simNotional > 0 ? { + notional: simNotional, + aFees: simNotional * rateA, + bFees: simNotional * rateB, + saved: Math.abs(simNotional * rateA - simNotional * rateB), + cheaperSlug: rateA < rateB ? venueA : rateB < rateA ? venueB : null, + } : null; + + return NextResponse.json({ + wallet: walletProvided ? wallet.toLowerCase() : null, + dydxAddress: dydxProvided ? dydxAddress : null, + days, + generatedAt: Date.now(), + venueA: venueAResult, + venueB: venueBResult, + comparison, + simulated, + }); + } catch (err) { + console.error("[fee-compare]", err); + return NextResponse.json({ error: "fetch_failed" }, { status: 502 }); + } +} diff --git a/src/app/api/internal/revalidate-aggregate/route.ts b/src/app/api/internal/revalidate-aggregate/route.ts index 39d221d9..0fdde6a4 100644 --- a/src/app/api/internal/revalidate-aggregate/route.ts +++ b/src/app/api/internal/revalidate-aggregate/route.ts @@ -44,5 +44,10 @@ export async function POST(req: Request): Promise { // worker publish. revalidateTag("benchmarks", "default"); revalidateTag("data-api-cohort", "default"); - return NextResponse.json({ revalidated: true, tags: ["bench-aggregate", "benchmarks", "data-api-cohort"] }); + // Invalidate HL cohort caches (builder stats, history blob, leaderboard) + // so new builders added to Prometheus (e.g. fomo) surface on the next + // request without waiting for the 1h unstable_cache TTL to expire. + revalidateTag("hl-cohort", "default"); + revalidateTag("hl-history", "default"); + return NextResponse.json({ revalidated: true, tags: ["bench-aggregate", "benchmarks", "data-api-cohort", "hl-cohort", "hl-history"] }); } diff --git a/src/app/fee-compare/page.tsx b/src/app/fee-compare/page.tsx new file mode 100644 index 00000000..ad2fed51 --- /dev/null +++ b/src/app/fee-compare/page.tsx @@ -0,0 +1,35 @@ +import type { Metadata } from "next"; +import { pageMetadata } from "@/lib/page-metadata"; +import { FeeCompareClient } from "@/components/fee-compare-client"; + +export const metadata: Metadata = pageMetadata({ + path: "/fee-compare", + title: "Perp DEX fee comparison — any venue", + description: + "Compare taker fees between any two perp DEXs. Paste a wallet to see what was actually paid on Hyperliquid or Gains and what it would have cost elsewhere. Live on-chain data, no API key.", +}); + +export default function FeeComparePage() { + return ( +
+

+ Fee comparison +

+

+ Compare perp DEX fees +

+

+ Select any two venues to compare taker rates. When comparing Hyperliquid or Gains, + paste a wallet address to see real fees from your trade history and what those same + trades would have cost on the other platform. +

+

+ No API key required. Rates fetched live from public endpoints. +

+ +
+ +
+
+ ); +} diff --git a/src/components/fee-compare-client.tsx b/src/components/fee-compare-client.tsx new file mode 100644 index 00000000..311bf5d1 --- /dev/null +++ b/src/components/fee-compare-client.tsx @@ -0,0 +1,1164 @@ +"use client"; + +import { useState } from "react"; +import Image from "next/image"; +import { + ArrowRight, + Loader2, + AlertCircle, + Zap, + ChevronDown, + ChevronUp, +} from "lucide-react"; + +// ────────────────────────────────────────────────────────────────────── +// Venue list +// ────────────────────────────────────────────────────────────────────── + +const COMPARABLE_VENUES = [ + { slug: "hyperliquid", name: "Hyperliquid", chain: "Hyperliquid L1" }, + { slug: "gains", name: "Gains", chain: "Arbitrum / Base" }, + { slug: "dydx", name: "dYdX v4", chain: "Cosmos" }, + { slug: "gmx-v2", name: "GMX v2", chain: "Arbitrum" }, + { slug: "paradex", name: "Paradex", chain: "Starknet" }, + { slug: "edgex", name: "EdgeX", chain: "zkSync" }, +] as const; + +type VenueSlug = (typeof COMPARABLE_VENUES)[number]["slug"]; + +// Venues that accept an EVM 0x wallet address +const EVM_WALLET_VENUES: VenueSlug[] = ["hyperliquid", "gains", "gmx-v2"]; + +const VENUE_LOGOS: Partial> = { + hyperliquid: "/logos/hyperliquid.png", + gains: "/logos/gains.png", + dydx: "/logos/dydx.svg", + "gmx-v2": "/logos/gmx.svg", + paradex: "/logos/paradex.jpg", + edgex: "/logos/edgex.jpg", +}; + +// ────────────────────────────────────────────────────────────────────── +// Types +// ────────────────────────────────────────────────────────────────────── + +type HlFillRow = { + time: number; + coin: string; + dir: string; + side: string; + notional: number; + hlFee: number; + equivFee?: number; + closedPnl: number; + isTaker: boolean; +}; + +type HlTopCoin = { + coin: string; + fills: number; + notional: number; + fees: number; +}; + +type HlWalletData = { + fills: number; + notionalUsd: number; + feesUsd: number; + fundingUsd: number; + netCostUsd: number; + avgFeeRateBps: number; + topCoins: HlTopCoin[]; + recentFills: HlFillRow[]; +}; + +type GainsWalletData = { + events: number; + feesUsdc: number; + positionSizeUsdc: number; + avgFeeRateBps: number; +}; + +type GmxWalletData = { + trades: number; + feesUsdc: number; + notionalUsd: number; + avgFeeRateBps: number; +}; + +type DydxWalletData = { + fills: number; + feesUsdc: number; + notionalUsd: number; + avgFeeRateBps: number; +}; + +type AnyWallet = HlWalletData | GainsWalletData | GmxWalletData | DydxWalletData; + +type VenueResult = { + slug: string; + name: string; + ratePerAction: number; + rateBps: number; + rateNote: string; + rateIsLive: boolean; + wallet: AnyWallet | null; + effectiveRateBps?: number; + effectiveRateNote?: string; +}; + +type SimResult = { + notionalUsed: number; + feesActual: number; + equivFees: number; + saved: number; + multiple: number | null; + fundingUsd?: number; +}; + +type ComparisonResult = { + aToBSim: SimResult | null; + bToASim: SimResult | null; +}; + +type FeeCompareResult = { + wallet: string | null; + dydxAddress: string | null; + days: number; + generatedAt: number; + venueA: VenueResult; + venueB: VenueResult; + comparison: ComparisonResult; +}; + +// ────────────────────────────────────────────────────────────────────── +// Wallet data helpers (slug-based instead of type guards) +// ────────────────────────────────────────────────────────────────────── + +function walletFees(slug: string, w: AnyWallet): number { + if (slug === "hyperliquid") return (w as HlWalletData).feesUsd; + return (w as GainsWalletData | GmxWalletData | DydxWalletData).feesUsdc; +} + +function walletVolume(slug: string, w: AnyWallet): number { + if (slug === "hyperliquid") return (w as HlWalletData).notionalUsd; + if (slug === "gains") return (w as GainsWalletData).positionSizeUsdc; + return (w as GmxWalletData | DydxWalletData).notionalUsd; +} + +function walletLabel(slug: string, w: AnyWallet): string { + if (slug === "hyperliquid") return `${(w as HlWalletData).fills} fills`; + if (slug === "gains") return `${(w as GainsWalletData).events} trades`; + if (slug === "gmx-v2") return `${(w as GmxWalletData).trades} trades`; + if (slug === "dydx") return `${(w as DydxWalletData).fills} fills`; + return ""; +} + +function walletHasActivity(slug: string, w: AnyWallet): boolean { + if (slug === "hyperliquid") return (w as HlWalletData).fills > 0; + if (slug === "gains") return (w as GainsWalletData).events > 0; + if (slug === "gmx-v2") return (w as GmxWalletData).trades > 0; + if (slug === "dydx") return (w as DydxWalletData).fills > 0; + return false; +} + +// ────────────────────────────────────────────────────────────────────── +// Helpers +// ────────────────────────────────────────────────────────────────────── + +function fmt(n: number, decimals = 2) { + return n.toLocaleString("en-US", { + minimumFractionDigits: decimals, + maximumFractionDigits: decimals, + }); +} + +function fmtUsd(n: number) { + const abs = Math.abs(n); + const sign = n < 0 ? "-" : ""; + if (abs >= 1000) return sign + "$" + fmt(abs, 0); + return sign + "$" + fmt(abs, 2); +} + +function fmtDate(ms: number) { + return new Date(ms).toLocaleString("en-US", { + month: "short", + day: "numeric", + hour: "2-digit", + minute: "2-digit", + }); +} + +// ────────────────────────────────────────────────────────────────────── +// Atoms +// ────────────────────────────────────────────────────────────────────── + +function VenueLogo({ slug, size = 28 }: { slug: string; size?: number }) { + const src = VENUE_LOGOS[slug as VenueSlug]; + if (!src) { + return ( +
+ + {slug.slice(0, 2)} + +
+ ); + } + return ( + {slug} + ); +} + +function DirBadge({ dir }: { dir: string }) { + const d = dir.toLowerCase(); + const isOpen = d.includes("open"); + const isLong = d.includes("long"); + const cls = isOpen + ? isLong ? "bg-emerald-500/12 text-emerald-500" : "bg-red-400/12 text-red-400" + : isLong ? "bg-emerald-500/8 text-emerald-500/60" : "bg-red-400/8 text-red-400/60"; + return ( + + {dir} + + ); +} + +function MakerBadge() { + return ( + + maker + + ); +} + +function CheaperBadge() { + return ( + + + Cheaper + + ); +} + +function LiveBadge() { + return ( + + + Live + + ); +} + +function ProtocolBadge() { + return ( + + Protocol + + ); +} + +// ────────────────────────────────────────────────────────────────────── +// VenueDropdown +// ────────────────────────────────────────────────────────────────────── + +function VenueDropdown({ + label, + value, + exclude, + onChange, +}: { + label: string; + value: VenueSlug; + exclude: VenueSlug; + onChange: (v: VenueSlug) => void; +}) { + const venue = COMPARABLE_VENUES.find((v) => v.slug === value)!; + return ( +
+ +
+
+ +
+ +
+ +
+
+

{venue.chain}

+
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// RateCard +// ────────────────────────────────────────────────────────────────────── + +function RateComparisonCard({ + venueA, + venueB, +}: { + venueA: VenueResult; + venueB: VenueResult; +}) { + const aBps = venueA.effectiveRateBps ?? venueA.rateBps; + const bBps = venueB.effectiveRateBps ?? venueB.rateBps; + const aRate = venueA.effectiveRateBps !== undefined ? venueA.effectiveRateBps / 10000 : venueA.ratePerAction; + const bRate = venueB.effectiveRateBps !== undefined ? venueB.effectiveRateBps / 10000 : venueB.ratePerAction; + const aWins = aRate < bRate; + const bWins = bRate < aRate; + const diff = Math.abs(aBps - bBps); + const usingEffective = venueA.effectiveRateBps !== undefined || venueB.effectiveRateBps !== undefined; + + return ( +
+
+

Fee rates

+

+ {usingEffective ? "Effective rate based on your fills" : "Per-action taker rate comparison"} +

+
+
+
+
+ +

{venueA.name}

+ {aWins && diff > 0.1 && } +
+

+ {fmt(aBps, 2)} + bps +

+
+ {venueA.rateIsLive ? : } +

{venueA.rateNote}

+
+ {venueA.effectiveRateNote && ( +

{venueA.effectiveRateNote}

+ )} +
+ +
+
+
+ VS +
+
+
+ +
+
+ +

{venueB.name}

+ {bWins && diff > 0.1 && } +
+

+ {fmt(bBps, 2)} + bps +

+
+ {venueB.rateIsLive ? : } +

{venueB.rateNote}

+
+ {venueB.effectiveRateNote && ( +

{venueB.effectiveRateNote}

+ )} +
+
+ {diff > 0.01 ? ( +
+ {aWins ? ( +

+ {venueA.name} is{" "} + {fmt(diff, 2)} bps cheaper + {usingEffective ? " (for your coins)" : " per action"} + {bBps > 0 && ( + + ( + {fmt( + ((bRate - aRate) / bRate) * 100, + 0 + )} + % less) + + )} +

+ ) : ( +

+ {venueB.name} is{" "} + {fmt(diff, 2)} bps cheaper + {usingEffective ? " (for your coins)" : " per action"} + {aBps > 0 && ( + + ( + {fmt( + ((aRate - bRate) / aRate) * 100, + 0 + )} + % less) + + )} +

+ )} +
+ ) : ( +
+

Rates are approximately equal

+
+ )} +
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// SimBox — shared comparison sub-card +// ────────────────────────────────────────────────────────────────────── + +function SimBox({ + sim, + otherName, + thisName, +}: { + sim: SimResult; + otherName: string; + thisName: string; +}) { + return ( +
+

+ Same trades on {otherName} +

+

0.5 + ? "text-emerald-500" + : sim.saved < -0.5 + ? "text-red-400" + : "text-ink" + }`} + > + {fmtUsd(sim.equivFees)} +

+ {sim.saved > 0.5 && ( +

+ {thisName} total advantage: {fmtUsd(sim.saved)} + {sim.feesActual < -0.01 + ? ` (${fmtUsd(sim.equivFees)} equiv + ${fmtUsd(Math.abs(sim.feesActual))} earned)` + : sim.multiple && sim.multiple > 1.05 + ? ` (${fmt(sim.multiple, 1)}x cheaper)` + : ""} +

+ )} + {sim.saved < -0.5 && ( +

+ {otherName} would save {fmtUsd(Math.abs(sim.saved))} +

+ )} + {Math.abs(sim.saved) <= 0.5 && ( +

Roughly equal cost

+ )} + {sim.fundingUsd !== undefined && Math.abs(sim.fundingUsd) > 0.5 && ( +

+ +{" "} + {sim.fundingUsd > 0 + ? `${fmtUsd(sim.fundingUsd)} funding received` + : `${fmtUsd(Math.abs(sim.fundingUsd))} funding paid`}{" "} + on {thisName} +

+ )} +
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// WalletSummaryCard +// ────────────────────────────────────────────────────────────────────── + +function WalletSide({ + venue, + otherVenue, + sim, + crossSim, +}: { + venue: VenueResult; + otherVenue: VenueResult; + sim: SimResult | null; + crossSim?: SimResult | null; +}) { + const w = venue.wallet; + const hasActivity = w !== null && walletHasActivity(venue.slug, w); + + if (!hasActivity) { + if (crossSim) { + return ( +
+
+ +
+

{venue.name}

+

No activity found

+
+
+
+

+ {otherVenue.name} trades would cost here +

+

+ {fmtUsd(crossSim.equivFees)} +

+ {crossSim.saved > 0.5 && ( +

+ {otherVenue.name} total advantage: {fmtUsd(crossSim.saved)} + {crossSim.feesActual < -0.01 + ? ` (earned ${fmtUsd(Math.abs(crossSim.feesActual))} in rebates)` + : ""} +

+ )} + {crossSim.saved < -0.5 && ( +

+ {venue.name} saves {fmtUsd(Math.abs(crossSim.saved))} +

+ )} +

+ Projection based on {otherVenue.name} history +

+
+
+ ); + } + return

No {venue.name} activity

; + } + + const fees = walletFees(venue.slug, w); + const volume = walletVolume(venue.slug, w); + const avgBps = w.avgFeeRateBps; + const label = walletLabel(venue.slug, w); + + return ( +
+
+ +
+

{venue.name}

+ {label &&

{label}

} +
+
+ +
+ {fees < -0.01 ? ( + <> +

+ +{fmtUsd(Math.abs(fees))} +

+

maker rebates earned

+ + ) : ( +

+ {fmtUsd(fees)} +

+ )} +

{fmt(Math.abs(avgBps), 2)} bps avg

+
+ + {/* Venue-specific extra stats */} + {venue.slug === "hyperliquid" && ( +
+
+

Volume

+

+ {fmtUsd(volume)} +

+
+
+

Net cost

+

+ {fmtUsd((w as HlWalletData).netCostUsd)} +

+ {Math.abs((w as HlWalletData).fundingUsd) > 0.5 ? ( +

+ fees {fmtUsd(fees)}{" "} + {(w as HlWalletData).fundingUsd > 0 + ? `+ ${fmtUsd((w as HlWalletData).fundingUsd)} rcvd` + : `– ${fmtUsd(Math.abs((w as HlWalletData).fundingUsd))} paid`} +

+ ) : ( +

after funding

+ )} +
+
+ )} + {venue.slug !== "hyperliquid" && ( +
+

Volume

+

{fmtUsd(volume)}

+
+ )} + + {sim && ( + + )} +
+ ); +} + +function WalletSummaryCard({ result }: { result: FeeCompareResult }) { + const { venueA, venueB, comparison } = result; + + const hasAData = venueA.wallet !== null && walletHasActivity(venueA.slug, venueA.wallet); + const hasBData = venueB.wallet !== null && walletHasActivity(venueB.slug, venueB.wallet); + + if (!hasAData && !hasBData) { + return ( +
+

+ No trades found in the last {result.days} days on either platform. +

+
+ ); + } + + return ( +
+
+

Wallet analysis

+

+ Actual fees paid vs simulated cost on the other platform +

+
+
+
+ +
+
+
+
+ VS +
+
+
+
+ +
+
+
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// HlTopCoinsCard +// ────────────────────────────────────────────────────────────────────── + +function HlTopCoinsCard({ + topCoins, + venueName, +}: { + topCoins: HlTopCoin[]; + venueName: string; +}) { + if (topCoins.length === 0) return null; + return ( +
+
+ +

{venueName} top markets

+
+
+ {topCoins.map((c) => ( +
+ + {c.coin} + + {c.fills} fills +
+
+
+
+
+ + {fmtUsd(c.notional)} + + + {fmtUsd(c.fees)} + +
+ ))} +
+
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// HlTradeTable +// ────────────────────────────────────────────────────────────────────── + +function HlTradeTable({ + fills, + venueName, + venueSlug, + otherVenueName, +}: { + fills: HlFillRow[]; + venueName: string; + venueSlug: string; + otherVenueName?: string; +}) { + const [showAll, setShowAll] = useState(false); + const PREVIEW = 10; + const rows = showAll ? fills : fills.slice(0, PREVIEW); + const hasEquiv = !!otherVenueName && fills.some((f) => f.equivFee !== undefined); + + if (fills.length === 0) return null; + + return ( +
+
+
+ +

+ {hasEquiv ? `${venueName} vs ${otherVenueName} — per trade` : `${venueName} trade history`} +

+
+

{fills.length} fills

+
+
+ + + + + + + + + {hasEquiv && ( + + )} + {hasEquiv && ( + + )} + {!hasEquiv && ( + + )} + + + + {rows.map((f, i) => { + const isOpen = f.closedPnl === 0 && !f.dir.toLowerCase().includes("close"); + const diff = hasEquiv && f.equivFee !== undefined ? f.equivFee - f.hlFee : undefined; + return ( + + + + + + + {hasEquiv && f.equivFee !== undefined && ( + + )} + {hasEquiv && diff !== undefined && ( + + )} + {!hasEquiv && ( + + )} + + ); + })} + +
+ Date + + Market + + Direction + + Notional + + {venueName} fee + + {otherVenueName} fee + + Diff + + PnL +
+ {fmtDate(f.time)} + +
+ {f.coin} + {!f.isTaker && } +
+ 		+ + + {fmtUsd(f.notional)} + + {fmtUsd(f.hlFee)} + f.hlFee ? "text-red-400" : "text-ink-faint" + }`}> + {fmtUsd(f.equivFee)} + + {isOpen ? ( + open + ) : f.closedPnl > 0 ? ( + + +{fmtUsd(f.closedPnl)} + + ) : f.closedPnl < 0 ? ( + + {fmtUsd(f.closedPnl)} + + ) : ( + $0 + )} +
+
+ {fills.length > PREVIEW && ( + + )} +
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// Footnote +// ────────────────────────────────────────────────────────────────────── + +function Footnote({ venueA, venueB }: { venueA: VenueResult; venueB: VenueResult }) { + const hasHl = venueA.slug === "hyperliquid" || venueB.slug === "hyperliquid"; + const hasGains = venueA.slug === "gains" || venueB.slug === "gains"; + const hasGmx = venueA.slug === "gmx-v2" || venueB.slug === "gmx-v2"; + const hasDydx = venueA.slug === "dydx" || venueB.slug === "dydx"; + + return ( +

+ {hasHl && ( + <>Hyperliquid: taker rate fetched live from HL fee schedule API. Fills via HL info endpoint. + )} + {hasGains && ( + <> + Gains: on-chain FeesProcessed events (Arbitrum). + Rates fetched live per-coin from backend-arbitrum.gains.trade.{" "} + + )} + {hasGmx && ( + <> + GMX v2: fills and rate from Subsquid indexer ( + positionFeeAmount / 1e6). Rate = live avg of recent 50 trades.{" "} + + )} + {hasDydx && ( + <> + dYdX v4: public indexer fills. Rate = 5 bps tier-0 (protocol-governed). Address must be{" "} + dydx1... Cosmos format.{" "} + + )} + Paradex and EdgeX rates fetched live from their public APIs. Funding excluded from all comparisons. +

+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// Results +// ────────────────────────────────────────────────────────────────────── + +function Results({ result }: { result: FeeCompareResult }) { + const { venueA, venueB } = result; + + const hasWalletData = + (venueA.wallet !== null && walletHasActivity(venueA.slug, venueA.wallet)) || + (venueB.wallet !== null && walletHasActivity(venueB.slug, venueB.wallet)); + + const hlVenueA = + venueA.slug === "hyperliquid" && venueA.wallet + ? (venueA.wallet as HlWalletData) + : null; + const hlVenueB = + venueB.slug === "hyperliquid" && venueB.wallet + ? (venueB.wallet as HlWalletData) + : null; + + return ( +
+ + {hasWalletData && } + {hlVenueA && hlVenueA.topCoins.length > 0 && ( + + )} + {hlVenueA && hlVenueA.recentFills.length > 0 && ( + + )} + {hlVenueB && hlVenueB.topCoins.length > 0 && ( + + )} + {hlVenueB && hlVenueB.recentFills.length > 0 && ( + + )} + +
+ ); +} + +// ────────────────────────────────────────────────────────────────────── +// FeeCompareClient +// ────────────────────────────────────────────────────────────────────── + +export function FeeCompareClient() { + const [venueA, setVenueA] = useState("hyperliquid"); + const [venueB, setVenueB] = useState("gains"); + const [wallet, setWallet] = useState(""); + const [dydxAddress, setDydxAddress] = useState(""); + const [days, setDays] = useState(90); + const [loading, setLoading] = useState(false); + const [result, setResult] = useState(null); + const [error, setError] = useState(null); + + const needsEvmWallet = + EVM_WALLET_VENUES.includes(venueA) || EVM_WALLET_VENUES.includes(venueB); + const needsDydxAddr = venueA === "dydx" || venueB === "dydx"; + + function handleVenueAChange(v: VenueSlug) { + setVenueA(v); + if (v === venueB) setVenueB(venueA); + setResult(null); + } + + function handleVenueBChange(v: VenueSlug) { + setVenueB(v); + if (v === venueA) setVenueA(venueB); + setResult(null); + } + + async function analyze() { + const trimmed = wallet.trim(); + const dydxTrimmed = dydxAddress.trim(); + + if (needsEvmWallet && trimmed && !/^0x[0-9a-fA-F]{40}$/.test(trimmed)) { + setError("Enter a valid Ethereum address (0x...)"); + return; + } + if (needsDydxAddr && dydxTrimmed && !/^dydx1[a-z0-9]{38}$/.test(dydxTrimmed)) { + setError("Enter a valid dYdX address (dydx1...)"); + return; + } + + setLoading(true); + setError(null); + setResult(null); + + try { + const params = new URLSearchParams({ venueA, venueB, days: String(days) }); + if (trimmed) params.set("wallet", trimmed); + if (dydxTrimmed) params.set("dydxAddress", dydxTrimmed); + + const res = await fetch(`/api/fee-compare?${params}`); + if (!res.ok) { + const d = (await res.json().catch(() => ({}))) as { error?: string }; + setError( + res.status === 429 + ? "Rate limited — wait a moment and try again." + : d.error ?? "Something went wrong." + ); + return; + } + setResult((await res.json()) as FeeCompareResult); + } catch { + setError("Network error — check your connection."); + } finally { + setLoading(false); + } + } + + return ( +
+
+ {/* Venue selectors */} +
+ +
VS
+ +
+ + {/* EVM wallet — shown when HL, Gains, or GMX v2 selected */} +
+ + setWallet(e.target.value)} + onKeyDown={(e) => e.key === "Enter" && !loading && analyze()} + placeholder="0x..." + spellCheck={false} + disabled={!needsEvmWallet} + className={`w-full rounded-xl border border-ink/15 bg-paper px-3.5 py-2.5 font-mono text-sm placeholder:text-ink-faint focus:border-ink/40 focus:outline-none transition-colors ${ + needsEvmWallet ? "text-ink" : "text-ink-faint/40 cursor-not-allowed" + }`} + /> +
+ + {/* dYdX address — only shown when dYdX is one of the venues */} + {needsDydxAddr && ( +
+ + setDydxAddress(e.target.value)} + onKeyDown={(e) => e.key === "Enter" && !loading && analyze()} + placeholder="dydx1..." + spellCheck={false} + className="w-full rounded-xl border border-ink/15 bg-paper px-3.5 py-2.5 font-mono text-sm text-ink placeholder:text-ink-faint focus:border-ink/40 focus:outline-none transition-colors" + /> +
+ )} + +
+
+ + Period + + {[30, 90, 180].map((d) => ( + + ))} +
+ +
+
+ + {error && ( +
+ + {error} +
+ )} + + {result && } +
+ ); +} 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",