Cross-Currency Arbitrage Chains: Finding Profitable Routes Across Uniswap, Curve, and Balancer

Arbitrage opportunities in decentralized finance emerge continuously as price discrepancies form across fragmented liquidity pools. A token trading at $1.05 on Uniswap V3 while priced at $0.98 on Curve creates a measurable spread, but capturing it requires identifying the route, calculating slippage, accounting for gas costs, and executing before network conditions change. The technical challenge intensifies when profitable paths span multiple protocols, separate blockchains, or require chained swaps through intermediate tokens where each hop compounds slippage and fees.

Operators of arbitrage bots face a constraint that manual traders do not: execution must be atomic, cost-effective, and immune to front-running or sandwich attacks that extract value from visible transaction flows. A 2% price difference sounds attractive until gas fees consume 0.8%, MEV extraction claims 0.4%, and slippage on the return leg removes another 0.5%. This article examines how to map multi-hop swap paths across Uniswap, Curve, and Balancer using real fee structures, identify routes that survive cost deduction, and execute with protection against extraction.

Mapping the protocol landscape and fee structures

Each protocol operates under different fee models and liquidity concentration patterns. Uniswap V3 introduced tiered fees—0.05%, 0.30%, 0.60%, and 1.00%—allowing liquidity providers to choose their risk-reward profile. Concentrated liquidity means capital efficiency varies: capital concentrated in narrow price ranges can support higher trading volumes with smaller reserves, but liquidity can evaporate if price moves beyond that range. When calculating swap costs, the effective fee depends not on the tier alone but on where current price sits relative to the liquidity distribution.

Curve specializes in stablecoin and correlated-asset trading through its bonding curve formula, which differs from Uniswap’s constant product model. Low fees—typically 0.04%—make Curve attractive for high-frequency volume, but the curve’s design creates different slippage profiles. Large trades hitting correlated-asset pools like 3pool (USDC, USDT, DAI) experience minimal slippage; the same trade across Curve pools without deep correlation can exhibit sharp price movement. Balancer extends this further with customizable pool weights and multiple token combinations, enabling multi-token swaps and asymmetric liquidity structures that create distinct arbitrage opportunities.

The first mapping step is to query current state: reserve balances, fee percentages, and liquidity concentration (for Uniswap V3). Tools like The Graph provide indexed data, but for real-time arbitrage accuracy, direct RPC calls to pool contracts are essential. A hypothetical example: USDC-WETH on Uniswap V3 0.30% tier holds 5,000 ETH and 8,000,000 USDC; a Curve tricrypto pool holds different ratios; Balancer’s WETH-USDC pool holds yet another. The same 100 ETH trade produces different output prices across all three, and identifying which route is most profitable requires calculating the actual output accounting for all fee tiers in the path.

Network selection also matters. Uniswap operates on Ethereum mainnet, Arbitrum, Optimism, Base, and Polygon. Gas costs differ dramatically: mainnet arbitrage requires spreads of at least 0.5–1.5% to be worthwhile due to transaction costs; Layer 2 networks like Arbitrum lower that threshold to 0.1–0.3%. Profitable routes often cluster on cheaper networks where the same price discrepancy becomes economically viable for smaller spreads, leading to tighter competition among bots.

Building the route discovery algorithm

A practical arbitrage bot operates in two phases: discovery and execution. Discovery identifies potential routes by examining token pair prices across protocols. The simplest approach is a triangular arbitrage: buy token A with token B on protocol 1, swap A for C on protocol 2, and sell C back to B on protocol 3, closing the loop. More complex paths involve longer chains where each step consumes slippage and fees, requiring the bot to evaluate whether the final profit exceeds costs.

The algorithm begins by selecting a starting token—typically USDC, USDT, or ETH because they have deepest liquidity—and queries the output of a fixed input across all available routes. For a 1,000 USDC swap to WETH, the bot retrieves: (1) direct USDC-WETH output on Uniswap V3 0.05% tier, (2) USDC-USDT-WETH on Curve, (3) USDC-WETH on Balancer, and (4) any other path combining these protocols. Each path’s output is calculated using the AMM formula accounting for the actual fee structure. The bot then reverses the paths: swap the received WETH back to USDC across all protocols and compare which return path maximizes USDC output.

The critical calculation is the round-trip profit net of all costs. If the bot starts with 1,000 USDC, executes a swap, and receives 0.55 WETH, then swaps that WETH back and receives 1,002 USDC, the gross profit is 2 USDC. Subtract gas costs—typically $5–15 per transaction on mainnet—and any MEV extraction, and the trade might break even or lose money. On Arbitrum, the same 2 USDC gross profit survives gas costs of $0.05–0.20, creating actual profit. This asymmetry explains why Layer 2 arbitrage is more profitable than mainnet arbitrage despite lower trading volumes.

Route discovery can be simplified using a depth-first search of reachable token pairs, limiting search depth to prevent combinatorial explosion. A bot might search all 2-hop routes, then selectively evaluate 3-hop paths only when sufficient spread exists. Pre-filtering based on liquidity thresholds—ignoring pools below a certain reserve size—reduces processing time. The bot should also monitor recent trades on each pool to estimate actual slippage: a pool that experienced a large trade moments ago may have different effective pricing than its static reserves suggest.

Calculating slippage and impact pricing

The constant product formula x*y=k at Uniswap determines output price based on reserve changes. When a user swaps 1 token into a pool, they receive fewer tokens than the spot price suggests because the trade moves the price. For a USDC-WETH pool with 8,000,000 USDC and 5,000 WETH, the spot price is 1,600 USDC per WETH. Swapping 100,000 USDC increases reserves to 8,100,000, and the new WETH amount must satisfy the invariant: 8,100,000 × new_weth = 8,000,000 × 5,000 = 40,000,000,000. Solving: new_weth = 40,000,000,000 / 8,100,000 ≈ 4,938.27 WETH, meaning the trade received 61.73 WETH—less than the 62.5 WETH spot price would suggest.

The difference—61.73 versus 62.5—is slippage. Percentage slippage is (62.5 − 61.73) / 62.5 = 1.23%. This slippage increases with trade size relative to pool liquidity. A 1,000,000 USDC trade into the same pool would experience far higher slippage because it moves price more drastically. Curve’s different bonding curve reduces slippage for correlated assets but increases it for divergent pairs. Balancer’s weighted pools distribute slippage differently based on weights.

Accurate slippage calculation requires simulating each step of the path using current pool state. Many bots use eth_call to execute swap functions against the current block state without broadcasting a real transaction, retrieving the exact output. This is computationally cheap and essential for real-time decisions. Some operators pre-calculate slippage tables for common paths, updating them every block or every 10 seconds, trading freshness for speed.

One subtlety: quoted slippage is not the same as realized slippage. A bot may calculate that a 100 WETH swap will suffer 0.5% slippage based on current reserves, but by the time the transaction executes—potentially seconds later on mainnet—the pool may have moved due to intervening trades. If another bot executed a large swap moments before, slippage could be 1% instead of 0.5%. Protecting against this requires either slippage tolerance (accepting up to 1% slippage), or using time-weighted average price (TWAP) oracles to benchmark against recent average price rather than instantaneous price.

Protecting against MEV extraction and sandwich attacks

A visible arbitrage transaction in the mempool attracts MEV searchers who observe the trade, insert their own transaction before it (sandwich the original), and extract the price movement the arbitrage bot created. If a bot is buying WETH with USDC, a searcher can frontrun with the same trade (raising WETH price), let the bot execute at a worse rate, then backrun by unwinding the searcher’s position (capturing the profit the bot expected). The net effect: the bot loses value, the searcher extracts it.

Several mitigations exist. First, private mempools or MEV relays: services like Flashbots Protect or MEV-Blocker allow a user to submit transactions privately to a relay that bundles them with other transactions and submits them to validators. The transaction is not visible in the public mempool, reducing the window for sandwich attacks. The trade-off is trust: the relay operator sees the transaction, and there is no guarantee against MEV if the operator itself chooses to extract it.

Second, bundle execution: a bot can execute both legs of an arbitrage as a single bundle using MEV-resistant protocols or custom smart contracts. Instead of two separate swap transactions, one contract call atomically swaps token A to B on protocol 1, then B to A on protocol 2. If one leg fails, both fail, preventing attackers from partially sandwich the trade. Services like MEV-Share or proprietary protocols let bots submit bundles with explicit MEV protection.

Third, execution on Layer 2 networks: Arbitrum, Optimism, and Base process transactions faster and with less MEV visibility than mainnet Ethereum. While MEV still exists on Layer 2, the lower absolute value per transaction and faster block times reduce the incentive for extraction. A profitable 0.2% arbitrage on Arbitrum involves dollars of MEV; the same spread on mainnet might involve hundreds of dollars, attracting sophisticated searchers.

A robust bot should measure execution success: did the transaction execute at the price simulated, or was slippage worse than expected? Tracking this metric reveals whether MEV extraction or price movement are consistently eroding profitability. If slippage metrics degrade over time as more bots enter the market, it signals that routes that were profitable have become saturated, and the bot should shift focus to newer or more complex paths.

Multi-protocol execution and atomic settlement

A practical arbitrage path often spans multiple protocols, requiring careful sequencing. Consider: USDC → WETH on Uniswap V3 → ETH on Curve (bridging layer) → USDC back on Balancer. Each swap is a separate contract call. If the first swap executes but the second fails—perhaps due to insufficient liquidity or a pricing oracle rejection—the bot holds WETH with no ability to complete the arbitrage. The bot is now exposed to market risk rather than executing a hedged trade.

Atomic execution requires either (1) a flash loan to supply initial capital with the obligation to repay plus fees before the block ends, or (2) a router smart contract that chains multiple swaps with validation at each step. A flash loan—available through Aave, dYdX, Uniswap V3, or Balancer—allows a bot to borrow large amounts within a single transaction. The bot swaps the borrowed tokens, completes the arbitrage, repays the loan plus a small fee (typically 0.05%), and pockets the profit. Flash loans are atomic by design: if the repayment fails, the entire sequence reverts, leaving no orphaned tokens.

A router contract is alternative architecture. The bot deploys or uses a smart contract that encodes the full arbitrage path, accepting USDC as input and returning USDC as output. The contract internally calls Uniswap, Curve, and Balancer swap functions in sequence. If any swap fails, the entire transaction reverts. This approach is transparent on-chain and does not require flash loan availability, but it is slower and may consume more gas because of nested calls. Some bot operators combine both: use a flash loan for capital and a router for atomicity, ensuring the trade completes fully or not at all.

Gas optimization becomes critical at scale. Multi-protocol swaps consume more gas than single swaps. On mainnet, a complex 3-hop path might cost 200,000–400,000 gas. At 100 gwei gas price, this is $20–40 per trade. Profitable spreads must exceed these costs by a margin. Layer 2 networks dramatically reduce this constraint. The same transaction on Arbitrum might cost $0.10–0.30 in fees, enabling profitable arbitrage on much tighter spreads.

Data freshness and competitive automation

Arbitrage profitability depends on speed: the bot must identify opportunities and execute before other bots do. On mainnet, thousands of arbitrage bots compete, and profitable routes last seconds or milliseconds. The bot’s data must be fresher than competitors‘, requiring direct RPC connections rather than relying on public APIs like Infura. Some operators run their own Ethereum nodes to minimize latency and ensure consistent data availability.

Block time also affects strategy. Ethereum mainnet produces blocks roughly every 12 seconds. If a bot detects an opportunity and broadcasts a transaction, it competes with other transactions in the mempool. The block proposer selects which transactions to include, often prioritizing by fee. A bot offering higher gas prices gets included sooner, but this increases costs and erodes profit. Some bots use a „follow-the-leader“ strategy: monitor successful trades on-chain to identify which routes are profitable, then attempt the same arbitrage moments later. Others use MEV searcher networks or custom relay infrastructure to learn about incoming trades before they are public.

Profitable arbitrage often depends on being the first to act after a large swap creates a price discrepancy. If a whale swaps 1,000 ETH on Uniswap, the price impact creates an imbalance. Competing protocols temporarily offer better rates. A bot detecting this imbalance in the same block as the whale’s transaction can arbitrage the gap. This requires reactive design: continuously monitor large trades, instantly calculate routes, and submit transactions with no delay. Delays of even a few seconds allow other bots to exhaust the opportunity.

Layer 2 networks introduce different dynamics. Because blocks are produced faster (Arbitrum, for example, produces blocks roughly every 250 milliseconds), the time window for arbitrage is shorter but more frequent. A slower bot might miss many opportunities on Layer 2 due to latency, while a fast bot can execute multiple small arbitrages. This favors high-throughput bots and creates different competitive landscapes than mainnet. Some bot operators specialize in Layer 2 arbitrage specifically because the dynamics favor speed over capital size.

Building and testing a route discovery system

A practical route discovery system starts with data collection: continuously fetch reserve balances and prices from each protocol using The Graph subgraphs or direct RPC calls. Store this data in a local cache updated every 5–30 seconds (depending on the network). Build a graph of token pairs where edges represent available swaps, weighted by expected output accounting for slippage and fees. Use a shortest-path algorithm—Dijkstra’s or Bellman-Ford—to find the highest-output path from a starting token to an ending token.

For triangular arbitrage, the algorithm is simpler: pick three tokens, calculate the round-trip price for all 6 orderings, identify which offers profit. For longer paths, evaluate all plausible routes up to a depth limit. Pre-filter to exclude routes with poor liquidity or where slippage is clearly excessive. Once candidate routes are identified, simulate execution using eth_call to retrieve exact output, then evaluate whether gross profit exceeds costs (gas + MEV allowance).

Testing should use historical on-chain data rather than live trading initially. Replay historical blocks, calculate what arbitrage routes would have been profitable, and measure how many would have been profitably executed. This reveals whether the strategy has statistical edge and how sensitive profitability is to slippage assumptions, gas price changes, and execution latency. A common finding: strategies that look profitable on paper fail in practice because execution costs and MEV extraction consume the margin.

Once deployed, the bot should log all executions, measuring: actual slippage versus simulated, gas prices paid, MEV extracted, and realized profit. These metrics reveal whether the bot is operating as designed or degrading over time as the market becomes more competitive. If profitability declines, routes should be reassessed. You can learn more about Uniswap’s protocol mechanics and fee structures to refine route selection further.

Risk management and operational discipline

Arbitrage bot operations face several risks beyond simple unprofitability. Smart contract bugs can cause unexpected behavior; a malformed transaction or interaction with an exploited protocol can result in loss of capital. Operators should use time-tested protocols and audit their own smart contracts if deploying custom routers. Using well-established flash loan providers and interacting with Uniswap’s stable smart contracts reduces risk compared to integrating newer or untested protocols.

Liquidity risk is secondary but important. A route calculated to be profitable might fail to execute if liquidity dries up between simulation and execution. This is rare for major tokens like WETH, USDC, and USDT, but important for smaller tokens. The bot should verify that calculated routes involve sufficient depth to absorb the intended trade size without price slipping beyond tolerance.

Operational monitoring is essential. A bot running unattended can enter loss-making periods silently if routes become saturated or market conditions change. Regular reviews of executed trades, profitability metrics, and route performance inform whether the strategy still holds edge. Bots should have clear stop conditions: if profitability drops below target thresholds consistently, pause execution and reassess, rather than continuing to operate at a loss.

Tax and regulatory treatment varies by jurisdiction. Arbitrage trading is generally treated as income or capital gains depending on holding period. Some jurisdictions tax bots trading their own capital differently from bots earning fees as liquidity providers. Operators should consult tax professionals and maintain detailed transaction logs to support accurate reporting. The decentralized nature of arbitrage means tax authorities have less visibility than in centralized exchange trading, but this does not eliminate the obligation to report.