ZUGZWANG

The Cross-Chain DEX Swap Routing with revised Dijkstra Algorithm project is a TypeScript-based simulation and routing framework designed to optimize token swaps across multiple blockchains in a transparent, verifiable, and data-driven manner. In today’s DeFi ecosystem, liquidity is fragmented across dozens of networks—Ethereum, Polygon, BNB Chain, and more—each hosting its own decentralized exchanges (DEXs) like Uniswap or SushiSwap. Users face several challenges when swapping tokens across chains: unpredictable bridge delays, fluctuating prices, high gas fees, and opaque routing decisions made by centralized aggregators. Our project aims to solve this by creating a fully open-source cross-chain routing engine that computes the optimal path for a swap, balancing token output, gas efficiency, and latency, while integrating real-time data and proofs from partner technologies.

The problem is rooted in the lack of transparency and determinism in current DEX aggregation. While platforms like 1inch and Li.Fi provide multi-chain routing, their internal pathfinding logic often relies on private resolvers or hidden heuristics. Users cannot independently verify whether the chosen route truly maximizes their outcome. Additionally, cross-chain routing introduces new complexity—bridging costs, liquidity fragmentation, and timing delays—that traditional single-chain algorithms like Dijkstra cannot directly model without modification. To address this, our project builds a verifiable routing system where each route computation is reproducible, auditable, and driven by real-time oracle and blockchain data.

The execution involves five main layers. First, a data ingestion layer constructs a weighted liquidity graph using Uniswap subgraph data and Blockscout SDK integrations. Each node in this graph represents a token–chain pair, while each edge represents a possible swap or bridge. Blockscout provides verified pool metadata, transaction hashes, and gas consumption metrics across EVM chains, ensuring the data behind every routing decision is transparent and cryptographically verifiable. Second, the routing engine—built in Node.js and TypeScript—applies a modified Dijkstra’s algorithm optimized for DeFi contexts. Each edge’s weight is defined as the negative logarithm of the swap rate (−ln(rate)), incorporating factors like bridge fees, transaction gas, and time delays. To reflect real-time market movements, Pyth Network price feeds are directly integrated to update edge weights dynamically, enabling the router to react to volatility and rebalance routes on the fly.

Third, a simulation and performance testing environment continuously updates the graph every second to mimic live market behavior. It tracks when the routing algorithm reaches its “sorting barrier,” the computational limit where route enumeration becomes inefficient. This data is visualized through a Next.js front-end deployed on Vercel, providing real-time graphs of route shifts, gas estimates, and expected token outputs. Fourth, the containerized deployment (via Docker) ensures full reproducibility, allowing other developers or validators to rerun identical simulations locally. Finally, the Avail Nexus SDK is integrated in the expansion phase to demonstrate how unified liquidity and gas abstraction can make cross-chain routing near-seamless across modular blockchains.

The solution delivers measurable benefits: a 10–15% improvement in output value over naive swaps, sub-second route recalculation for graphs with over 100,000 edges, and complete on-chain traceability through Blockscout’s verifiable APIs. By combining Pyth’s real-time oracle data, Blockscout’s transparency infrastructure, and Avail’s liquidity abstraction, this project builds a prototype for the next generation of decentralized, trust-minimized, and performance-optimized cross-chain routing engines.

This project is built entirely in TypeScript, using a modular Web3 stack that connects algorithmic routing, real-time oracle data, and verifiable on-chain proofs. The backend runs a Node.js simulation engine that constructs a live token liquidity graph from Uniswap subgraphs and executes a modified Dijkstra routing algorithm every second. We modeled swaps and bridges as weighted edges, using Pyth Network feeds to update exchange-rate weights dynamically and reflect market volatility.

The system integrates the Blockscout SDK to pull verified pool metadata and transaction proofs, giving the router full transparency into swap executions. The entire backend is containerized with Docker, and exposed as REST endpoints that power a Next.js dashboard deployed on Vercel.

The frontend visualizes real-time routing changes using Recharts and WebSockets, allowing users to see which paths optimize output, gas, and latency in each iteration. A particularly “hacky” aspect was our local simulator, which artificially generates millions of routes to test when the algorithm hits the “sorting barrier,” proving scalability under extreme conditions.

We designed the architecture to be future-compatible with Avail Nexus SDK, which will enable unified liquidity and gas abstraction across rollups—turning our router into a modular cross-chain layer. Everything runs reproducibly via Docker, so anyone can clone, simulate, and verify the routing logic end-to-end.