Tools

Tools: Essential Guide: How I Built a Dijkstra-Based Money Routing Engine with 29K Edges

2026-03-24 0 views admin
Tools: Essential Guide: How I Built a Dijkstra-Based Money Routing Engine with 29K Edges

The problem nobody talks about

Modeling global money as a graph

The routing algorithm

Key design decisions

What I got wrong (and fixed)

The stack

What surprised me

Try it / break it A nurse in the Philippines sends $300 home every month. She's used the same service since 2012. She doesn't know that a two-step route through a stablecoin she's never heard of would save her $18 every month. Over twelve years, that's $2,500 — not stolen, just invisible. I wanted to build something that shows all the paths. Not a transfer service. Not a wallet. Just a map. That's Coinnect — an open-source routing engine that finds the cheapest way to move money between any two currencies using any combination of fiat, crypto, and P2P networks. The core insight: every exchange, remittance provider, and P2P market is just an edge in a directed graph. Right now the graph has 29,000+ edges across 50+ currencies, pulled from 45+ live data sources every 3 minutes: Every edge gets refreshed in parallel via asyncio.gather() in a background task. The whole refresh takes about 30 seconds. Finding the cheapest path from INR to GBP sounds simple until you realize the answer might be: While the "obvious" route — Wise at 2.8% — is almost 4x more expensive. The engine uses a modified Dijkstra with two passes: Compound cost, not additive. If you chain three 1% fees, the real cost isn't 3% — it's 1 - (0.99 × 0.99 × 0.99) = 2.97%. Small difference, but it matters when comparing routes. Provider deduplication. No exchange appears twice in a path. This prevents circular nonsense like Binance → X → Binance and forces genuine diversity across providers. Dual routing pass. The quote endpoint runs Dijkstra twice: once on the full graph (including reference FX bridges for exotic corridors), once on real providers only (to find pure crypto multi-hop routes that would otherwise be overshadowed by cheaper reference data). K-shortest paths, not just shortest. Classic Dijkstra prunes aggressively — once it visits BTC at step 1 via OKX, it blocks Kraken and Binance from reaching BTC at step 1. My state key includes the provider set, so different exchange combinations through the same currency all get explored. Max 4 hops. Beyond 4 steps, the accumulated fees and complexity make routes impractical. The safety cap is 200K heap pops. The 1% sanity check. I had a filter: they_receive > amount * 0.01 to catch garbage routes. Worked great for USD→MXN. Completely broke INR→GBP — because 388 GBP is the correct answer for 50,000 INR, but 388 < 500 (the threshold calculated in INR units). Fix: just check > 0. Counter was counting pushes. My safety cap of 50,000 iterations was counting heap pushes, not pops. With 29K edges, the counter hit 50K almost instantly without exploring anything useful. Switching to counting pops and raising the cap to 200K fixed it. Reference providers in user-facing routes. CoinGecko, central banks, and market rate bridges exist to help the router find exotic paths (like ZAR→ETB). But they're not real transfer services — you can't actually "send money via CoinGecko." I had to filter them from all user-facing results while keeping them available as intermediate hops. It's deliberately simple: No Kubernetes. No microservices. No Redis. The whole thing runs on a single VPS and handles the current load without breaking a sweat. The edges matter more than the algorithm. Dijkstra is a solved problem. The hard part is getting accurate, fresh data from 45+ sources with different rate limits, auth methods, response formats, and failure modes. Wise blocks you if you make too many requests. CoinGecko rate-limits at 30 req/min. Binance P2P requires a POST with specific body format. Each adapter is its own little battle. Reverse corridors are not obvious. I had USD→INR but not INR→GBP. Someone searched for it, got "no routes found," and I realized we were missing 55 reverse corridors across 10 providers. Now we log every failed search to catch these gaps. People don't compare. The nurse in the Philippines isn't lazy. The information genuinely doesn't exist in one place. Most comparison sites are affiliate-funded and only show providers that pay them. The structural incentive is broken. That's why this has to be non-profit. I built this alone over the past month. I'd genuinely appreciate feedback — especially on corridors that return wrong rates, providers I'm missing, or if you work in the remittance space and want to help. I'm looking for advisors and potentially a co-founder who knows this world better than I do. If you send money across borders, try your corridor. Tell me what's wrong. That's the most valuable thing you can do. Templates let you quickly answer FAQs or store snippets for re-use. Are you sure you want to ? It will become hidden in your post, but will still be visible via the comment's permalink. as well , this person and/or

Code Block

Copy

Nodes = currencies (USD, MXN, BTC, USDT, NGN, GBP...) Edges = conversion paths, each carrying: - exchange_rate - fee_pct - estimated_minutes - provider name CODE_BLOCK: Nodes = currencies (USD, MXN, BTC, USDT, NGN, GBP...) Edges = conversion paths, each carrying: - exchange_rate - fee_pct - estimated_minutes - provider name CODE_BLOCK: Nodes = currencies (USD, MXN, BTC, USDT, NGN, GBP...) Edges = conversion paths, each carrying: - exchange_rate - fee_pct - estimated_minutes - provider name CODE_BLOCK: INR → USDT (CoinDCX, 0.5%) → BTC (MEXC, 0.1%) → GBP (Kraken, 0.16%) = 0.76% total CODE_BLOCK: INR → USDT (CoinDCX, 0.5%) → BTC (MEXC, 0.1%) → GBP (Kraken, 0.16%) = 0.76% total CODE_BLOCK: INR → USDT (CoinDCX, 0.5%) → BTC (MEXC, 0.1%) → GBP (Kraken, 0.16%) = 0.76% total COMMAND_BLOCK: def _dijkstra(graph, start, end, amount, optimize="cost", max_routes=5, max_steps=4): heap = [(0.0, 0, 0, start, amount, [])] results = [] visited_states = {} while heap and len(results) < max_routes: priority, _, steps, curr, curr_amount, path = heapq.heappop(heap) # Prune by (currency, provider_set) — allows different # exchange combos through the same intermediate currency providers_key = frozenset(e.via for e in path) state = (curr, providers_key) if state in visited_states and visited_states[state] <= priority: continue visited_states[state] = priority if curr == end and path: # Compound cost: 1 - ∏(1 - fee_i/100) product = 1.0 for e in path: product *= (1 - e.fee_pct / 100) results.append(((1 - product) * 100, curr_amount, path)) continue if steps >= max_steps: continue for edge in graph.get(curr, []): # No provider appears twice in a path if any(e.via == edge.via for e in path): continue new_amount = (curr_amount * edge.exchange_rate * (1 - edge.fee_pct / 100)) new_priority = priority + ( edge.fee_pct if optimize == "cost" else edge.estimated_minutes) heapq.heappush(heap, ( new_priority, ..., steps + 1, edge.to_currency, new_amount, path + [edge])) COMMAND_BLOCK: def _dijkstra(graph, start, end, amount, optimize="cost", max_routes=5, max_steps=4): heap = [(0.0, 0, 0, start, amount, [])] results = [] visited_states = {} while heap and len(results) < max_routes: priority, _, steps, curr, curr_amount, path = heapq.heappop(heap) # Prune by (currency, provider_set) — allows different # exchange combos through the same intermediate currency providers_key = frozenset(e.via for e in path) state = (curr, providers_key) if state in visited_states and visited_states[state] <= priority: continue visited_states[state] = priority if curr == end and path: # Compound cost: 1 - ∏(1 - fee_i/100) product = 1.0 for e in path: product *= (1 - e.fee_pct / 100) results.append(((1 - product) * 100, curr_amount, path)) continue if steps >= max_steps: continue for edge in graph.get(curr, []): # No provider appears twice in a path if any(e.via == edge.via for e in path): continue new_amount = (curr_amount * edge.exchange_rate * (1 - edge.fee_pct / 100)) new_priority = priority + ( edge.fee_pct if optimize == "cost" else edge.estimated_minutes) heapq.heappush(heap, ( new_priority, ..., steps + 1, edge.to_currency, new_amount, path + [edge])) COMMAND_BLOCK: def _dijkstra(graph, start, end, amount, optimize="cost", max_routes=5, max_steps=4): heap = [(0.0, 0, 0, start, amount, [])] results = [] visited_states = {} while heap and len(results) < max_routes: priority, _, steps, curr, curr_amount, path = heapq.heappop(heap) # Prune by (currency, provider_set) — allows different # exchange combos through the same intermediate currency providers_key = frozenset(e.via for e in path) state = (curr, providers_key) if state in visited_states and visited_states[state] <= priority: continue visited_states[state] = priority if curr == end and path: # Compound cost: 1 - ∏(1 - fee_i/100) product = 1.0 for e in path: product *= (1 - e.fee_pct / 100) results.append(((1 - product) * 100, curr_amount, path)) continue if steps >= max_steps: continue for edge in graph.get(curr, []): # No provider appears twice in a path if any(e.via == edge.via for e in path): continue new_amount = (curr_amount * edge.exchange_rate * (1 - edge.fee_pct / 100)) new_priority = priority + ( edge.fee_pct if optimize == "cost" else edge.estimated_minutes) heapq.heappush(heap, ( new_priority, ..., steps + 1, edge.to_currency, new_amount, path + [edge])) - 21 crypto exchanges via CCXT (Binance, Kraken, Coinbase, OKX...) - Wise live FX rates - Regional exchanges with direct REST APIs (Bitso, Buda, VALR, CoinDCX, WazirX) - Binance P2P real-time median prices for 12 emerging market currencies - 10 central bank official rates (Banxico, BCB, TRM, TCMB...) - 28 estimated remittance providers (Remitly, Western Union, Paysend, Nala...) - Reference FX bridges for exotic corridors (CurrencyAPI, Frankfurter, FloatRates) - FastAPI with 4 uvicorn workers - SQLite (WAL mode) for rate history and analytics - Tailwind CSS built from source (34KB, not the 300KB CDN) - Zero JavaScript frameworks — vanilla JS, template literals - One Python process on one Linux server - Live: coinnect.bot - API: GET https://coinnect.bot/v1/quote?from=USD&to=MXN&amount=500 - Code: github.com/coinnect-dev/coinnect (MIT) - Whitepaper: coinnect.bot/whitepaper

🏷️ Tags

toolsutilitiessecurity toolsessentialguidebuiltdijkstrabasedmoneyrouting

More from Tools

Tools: Gas-Aware Trading: Execute Only When Gas Is Cheap (2026)

Tools: Gas-Aware Trading: Execute Only When Gas Is Cheap (2026)

2026-03-30 0
Tools: Grafana k6 Has a Free API That Load Tests Your APIs With JavaScript - Full Analysis

Tools: Grafana k6 Has a Free API That Load Tests Your APIs With JavaScript - Full Analysis

2026-03-30 0
Tools: Caddy Has a Free API That Gives You Automatic HTTPS With Zero Configuration (2026)

Tools: Caddy Has a Free API That Gives You Automatic HTTPS With Zero Configuration (2026)

2026-03-30 0
Tools: Fly.io Has a Free API That Deploys Docker Apps Globally With Edge Hosting (2026)

Tools: Fly.io Has a Free API That Deploys Docker Apps Globally With Edge Hosting (2026)

2026-03-30 0

Trending

1

CVE-2025-61481: Critical Remote Code Execution Vulnerability in MikroTik RouterOS & SwitchOS

2025-10-27 • 189 views
2

CVE-2025-43939: Dell Unity OS Command Injection (High)

2025-10-30 • 148 views
3

Google disputes false claims of massive Gmail data breach

2025-10-30 • 130 views
4

Microsoft: DNS outage impacts Azure and Microsoft 365 services

2025-10-30 • 88 views
5

3.5B Accounts, 1 Critical Flaw: Meta Closes WhatsApp Data-Harvesting

2025-11-25 • 81 views