Triangular Arbitrage

The last lesson needed two venues to make money: ETH was cheap on one DEX, dear on another, and you walked the gap. But here’s the unsettling part — you don’t even need a second exchange. A single DEX, with three perfectly ordinary pools, can quietly contradict itself. Cycle a coin through the right loop and you come out the other side holding more of what you started with. No second venue. No price feed disagreeing. Just three pools that, multiplied together, don’t quite agree on what a dollar is worth.

Closing a loop

Classic foreign-exchange traders have hunted this for a century. Imagine a money-changer’s window quoting dollars, euros, and yen. Suppose you can turn 1 dollar into 0.9 euros, each euro into 160 yen, and each 144 yen back into 1 dollar. Walk that triangle — dollar → euro → yen → dollar — and if the three rates don’t line up, you finish the loop with more dollars than you began with, without ever predicting which way a currency will move. You just closed a loop that was internally inconsistent.

Triangular arbitrage is that exact trick, on-chain: cycle a starting asset through three (or more) pools and end with more of the asset you began with. The canonical loop is:

$\text{USDC} \rightarrow \text{ETH} \rightarrow \text{DAI} \rightarrow \text{USDC}$

Three swaps, three pools, back to where you started — ideally heavier. The beautiful (and slightly disturbing) part: no second venue is required. One DEX holding a USDC/ETH pool, an ETH/DAI pool, and a DAI/USDC pool is fully capable of being internally inconsistent, because each pool sets its price off its own reserves with nobody enforcing agreement between them.

When it matters

Most people picture arbitrage as “same thing, two prices.” Triangular arbitrage breaks that mental model: the mispricing isn’t in any one pair, it’s distributed around a loop. Bots that only scan pairs for cross-venue gaps miss it entirely. To catch it you have to think in cycles, not pairs — which is why triangular scanning is a distinct, and lucrative, corner of the MEV world.

The no-arbitrage condition

Here’s the whole game in one expression. Walk the loop and multiply the three exchange rates you receive at each leg. Call them $r_1$, $r_2$, $r_3$ (each one is “how much of the next asset you get per unit of the current asset”). In a perfectly consistent market:

$r_1 \cdot r_2 \cdot r_3 = 1$

That’s the no-arbitrage condition. A full round trip multiplies your starting amount by exactly that product. If the rates are mutually consistent, the product is 1, and you end with precisely what you began with — a pointless lap.

Now the two ways it can break:

• If $r_1 \cdot r_2 \cdot r_3 > 1$, cycling this direction multiplies your stake by more than 1 — profit. Run the loop USDC → ETH → DAI → USDC.
• If $r_1 \cdot r_2 \cdot r_3 < 1$, this direction loses money — but the reverse loop has product $1/(r_1 r_2 r_3) > 1$, so you cycle the other way instead.

So the product isn’t just a yes/no signal; its size tells you the edge and its position relative to 1 tells you the direction. A product of 1.005 is a 0.5% edge clockwise; a product of 0.995 is a 0.5% edge counter-clockwise.

When it matters

This single inequality is the entire detector. A triangular-arb bot doesn’t reason about ETH “going up” — it just multiplies rates around every loop it can find and pounces whenever a product strays from 1. The further from 1, the bigger the prize and the harder bots race to grab it. Equilibrium ($=1$) is the boring state the whole ecosystem is constantly dragging the market back toward.

A worked loop

Let’s make it concrete with the canonical numbers. Our one DEX quotes:

Multiply the loop. Going in, 1 USDC buys $1/2000$ ETH; that ETH fetches 2010 DAI each; each DAI fetches 1.00 USDC. The product of the rates around the loop is:

$\frac{1}{2000} \cdot 2010 \cdot 1.00 = \frac{2010}{2000} = 1.005$

A product of 1.005 — a clean 0.5% edge, cycling in this direction. Now run real money through it, starting with 100,000 USDC:

You started with 100,000 USDC and finished with 100,500 USDC — a gross profit of about 500 USDC for three swaps and a single block of patience. Notice that’s exactly $100{,}000 \times 0.005$: the loop product is the multiplier on your stake.

When it matters

This is the headline number — and, just like the cross-DEX “200 USDC spread,” it’s a lie of omission. The 500 USDC assumes every leg fills at the quoted rate no matter how much you push through. It won’t. The worked loop tells you an opportunity exists and which way to run it; it overstates what you actually pocket. The next section is where reality docks its cut.

Price impact shrinks the loop

Every leg of our loop is an AMM trade, and we already know what AMM trades do: they slide along the $x \cdot y = k$ curve and move the pool’s price against the trader. Buy ETH on leg 1 and the USDC/ETH pool’s ETH price climbs — you pay more than 2000 for the later units. Sell that ETH on leg 2 and the ETH/DAI pool’s ETH price sinks — you collect less than 2010 on the later units. Each leg quietly underdelivers versus its headline rate.

So the realized loop product is below the naive 1.005, and the true profit is less than 500 USDC. The visual below shows a single leg doing this — sell a token into a pool and the spot price (the slope from the origin) bends the wrong way with every unit:

Because the edge erodes as you scale, there’s an optimal cycle size — the very same hump from the last lesson. Trade too little and you leave the 0.5% mostly on the table; trade too much and price impact across all three legs claws the edge back, eventually dragging the realized product below 1 (a losing loop). Profit rises, peaks, and falls — and the peak depends on how deep the three pools are.

And don’t forget direction. Run the loop the wrong way and you start from product 0.995 — every leg compounds against you, so price impact isn’t your only problem; you were underwater before you pressed go. Always cycle the direction whose product exceeds 1.

When it matters

This closes the arc from the last lesson cleanly: detection is a multiplication (is the product off 1?), but extraction is an optimization (where’s the hump, and which direction?). Triangular bots that only check whether a loop is mispriced — without solving for size and direction — routinely fire trades that look like free money and settle for crumbs, or losses, after three rounds of price impact and gas. The edge is real; capturing it is a sizing problem.

Recap