On-chain arbitrage: atomic cycles, flash loans, and the auction you have to win

There is a comfortable myth that on-chain arbitrage is hard because the finding is hard — that somewhere in the price graph there is a hidden cycle only the cleverest algorithm can see, and whoever computes it fastest gets paid. The truth is almost the reverse. On a public chain, the profitable cycle is visible to everyone at the same instant, computed by dozens of bots running near-identical code against the same reserves. Detection is a solved, commoditized problem. What is hard — what actually decides who gets the money — is winning the ordering: landing your transaction in the right slot of the right block, ahead of every other searcher who found the exact same thing. On-chain arbitrage is easy to detect and hard to win, and the gap between those two verbs is where the entire economics of the business lives.

This article takes the searcher's side of the table. In MEV anatomy we mapped the dark forest from the victim's perspective and promised a follow-up on the benign extraction — the arbitrage and backrunning that keep on-chain prices honest. In on-chain liquidations we built a flash-loan execution contract and an oracle-backrun bundle and pointed here for the general treatment of the primitive. This piece pays both debts. It assumes you already know what a mempool, a bundle, and a priority fee are; if not, read the MEV piece first. Here we build the arbitrageur's machine: the atomic transaction that cannot lose, the borrowed capital that removes the capital constraint, the graph search that is the easy half, and the auction that eats almost all of the margin.

Atomicity: the trade that reverts on loss

The defining property of on-chain arbitrage — the thing that makes it categorically safer than any cross-venue trade a CEX trader can execute — is atomicity. A multi-hop arbitrage is not a sequence of trades you fire and hope land together. It is a single transaction that executes every leg of the cycle, and if the final balance is not strictly greater than the starting balance, the whole transaction reverts: every state change is rolled back as if it never happened, and you are out only the gas for a failed transaction.

This changes the risk profile completely. A CEX trader who buys BTC on one exchange to sell it on another holds inventory in between — for seconds, minutes, however long the transfer and the second fill take — and eats whatever the price does during that window. The on-chain arbitrageur holds inventory for zero time in any economically meaningful sense: the buy and the sell are the same indivisible operation. There is no mid-cycle price risk because there is no mid-cycle. Either the entire loop closes profitably in one atomic step, or it does not happen at all.

The guard that enforces this is a single comparison at the end of the execution path. Conceptually, an atomic arb contract does nothing more than:

// The whole cycle runs inside one transaction. If the closing balance
// does not clear the opening balance (plus costs), the require() throws,
// and the EVM reverts every trade that came before it.
function executeCycle(bytes calldata path, uint256 minProfit) external {
    uint256 start = IERC20(baseToken).balanceOf(address(this));

    _hopA(path);   // e.g. USDC -> WETH on Uniswap
    _hopB(path);   // e.g. WETH -> DAI  on Sushiswap
    _hopC(path);   // e.g. DAI  -> USDC on Curve

    uint256 end = IERC20(baseToken).balanceOf(address(this));
    require(end >= start + minProfit, "unprofitable");   // atomic safety net
}

The require is the entire safety model. A stale quote, a competing transaction that moved the pool one slot before yours, an unexpected fee — anything that turns the cycle unprofitable simply trips the guard and reverts. You never sell the last leg into a worse price than you modeled and eat the loss; the trade that would have lost money does not execute. This is why arbitrage is the benign end of the MEV taxonomy from the MEV piece: there is no victim whose fill is degraded, and the arbitrageur carries no directional inventory risk. The only real cost of a failed attempt is gas — which, as we will see, is exactly the cost the competitive auction is designed to inflate.

Flash loans remove the capital constraint

Atomicity enables something stronger: arbitrage with no capital of your own. A flash loan lets you borrow an arbitrary amount from a lending pool with exactly one condition — you repay it, plus a fee, before the transaction ends. Because the borrow, the arbitrage, and the repayment all live inside one atomic transaction, the pool faces no default risk: if you cannot repay, the whole transaction reverts and the loan is un-made. The lender is protected by the same revert that protects you.

The pattern is a callback. You call the pool's flash-loan function; the pool sends you the tokens and then calls you back; inside that callback you run the cycle and must leave enough to repay:

// Called by the lending pool in the middle of the flash loan.
function receiveFlashLoan(address token, uint256 amount, uint256 fee, bytes calldata data)
    external
{
    // 1. buy the asset cheap on venue A with the borrowed `amount`
    uint256 bought  = _swap(VENUE_A, token, ASSET, amount, data);
    // 2. sell it dear on venue B, back into the borrowed token
    uint256 repaidIn = _swap(VENUE_B, ASSET, token, bought, data);
    // 3. must be able to return principal + fee, or the whole tx reverts
    require(repaidIn >= amount + fee, "arb cannot cover loan");
    IERC20(token).transfer(msg.sender, amount + fee);   // repay in-tx
    // whatever remains — repaidIn - amount - fee — is profit, kept here
}

The fee is small and venue-dependent: Aave v3 charges 5 bps (0.05%) on a flash loan, Balancer historically charged 0 bps, and Uniswap v3 exposes the same capability through flash swaps where the fee is just the pool's normal swap fee. Five basis points is a real cost that must clear inside the cycle's margin, but it is trivial next to the alternative of tying up six or seven figures of your own inventory to capture a dislocation that lasts one block.

The consequence for the market structure is worth stating plainly: flash loans decouple arbitrage profit from capital. The winner of a given opportunity is not the searcher with the deepest balance sheet — a bot with a few dollars of gas money can borrow ten million dollars for the length of one transaction. Capital is not the moat. Everyone can borrow the same size against the same opportunity, which is precisely why the competition collapses onto the one thing that is not commoditized: getting ordered first.

A worked cross-DEX cycle

Numbers make the mechanics concrete. Take two constant-product WETH/USDC pools with the 0.30% fee ($\gamma = 0.997$), and suppose a large buy has just pushed pool B above pool A — the kind of dislocation the next section shows is where cycles actually come from. Use round, clearly illustrative reserves:

• Pool A (cheap): $x_A = 10{,}000$ WETH, $y_A = 30{,}000{,}000$ USDC $\Rightarrow$ price $3{,}000$ USDC/WETH.
• Pool B (dear): $x_B = 10{,}000$ WETH, $y_B = 30{,}600{,}000$ USDC $\Rightarrow$ price $3{,}060$ USDC/WETH.

The cycle is: flash-borrow USDC, buy WETH cheap on A, sell it dear on B, repay. Borrow $\Delta U = 100{,}000$ USDC. Hop 1 sells USDC into pool A for WETH:

$\Delta W = \frac{x_A\,\gamma\,\Delta U}{y_A + \gamma\,\Delta U} = \frac{10{,}000 \times 99{,}700}{30{,}000{,}000 + 99{,}700} \approx 33.12 \text{ WETH}.$

Hop 2 sells that WETH into pool B for USDC:

$\Delta U_{\text{out}} = \frac{y_B\,\gamma\,\Delta W}{x_B + \gamma\,\Delta W} = \frac{30{,}600{,}000 \times 33.02}{10{,}000 + 33.02} \approx 100{,}723 \text{ USDC}.$

You borrowed 100,000, received 100,723, and owe a 5 bps flash fee of 50 USDC. Net: about $673 gross profit on a capital outlay of zero, before gas and before the priority bid. Two things to notice. First, the two hops move the pools toward each other — buying on A lifts its price, selling on B drops its price — so profit is not linear in size: push too much and price impact eats the gap, exactly as in the sandwich optimization from the MEV piece. The searcher runs a one-dimensional search over $\Delta U$ to find the borrow size that maximizes net profit. Second, that $673 is a deterministic number every competing bot computes to the same value from the same reserves — which is the whole problem, and the subject of the auction section below.

Detection is the easy half

Given the market as a graph — assets as nodes, trading pairs as weighted edges — an arbitrage cycle is a loop whose product of exchange rates exceeds one. Take the logarithm of each rate, negate it, and a profitable cycle becomes a negative-weight cycle; the classical tool to find one is Bellman-Ford, with SPFA and the more recent RICH algorithm as faster variants tuned for the small, fast-changing graphs that real markets produce. That whole toolkit — the log transform, the negative-cycle condition, the Rust implementations, the fee-adjusted edge weights that kill most theoretical cycles — is the subject of graph algorithms for arbitrage detection, and there is no need to repeat it here.

What matters for this article is a single accounting point: the fee must go into the edge weight, or the cycle is a mirage. A three-leg loop pays three pool fees plus, if you borrowed, the flash-loan fee, and the negative-cycle test has to see all of them:

from math import log

def cycle_log_gain(rates, pool_fee=0.003, loan_fee=0.0005):
    """Log-gain around a cycle. > 0 means gross profit before gas and priority bid.
    `rates[i]` = units of the next asset per unit of the current one on hop i."""
    gross = 1.0
    for r in rates:
        gross *= r * (1 - pool_fee)     # each hop pays the venue's swap fee
    gross *= (1 - loan_fee)             # one flash-loan fee for the whole cycle
    return log(gross)                    # still ignores gas and the auction bid

Here is the load-bearing observation. That function is deterministic. Feed it the current on-chain reserves — which every node holds identically, because the chain is a shared, replicated state machine — and every searcher computes the same cycle_log_gain to the same value at the same block height. There is no private signal, no proprietary dataset, no informational edge. When a large swap or a new block reshuffles reserves, dozens of bots running structurally identical detection code all light up on the same cycle within milliseconds of each other. The search returns the same answer to everyone.

A note on topology, because it shapes how hard the search actually is. The cheapest cycles are triangular and intra-DEX — WETH → USDC → DAI → WETH entirely within one Uniswap deployment: three hops, three pool fees, no cross-venue coordination. Cross-DEX cycles (buy on Uniswap, sell on Sushiswap) add venues but leave the atomic guard identical. Longer, exotic cycles chain more hops still — but every extra hop multiplies another $(1-\text{fee})$ factor into the product, so the fee-adjusted negative-cycle condition kills long cycles fast. This is exactly why real searchers cap cycle length at three to five hops and prune aggressively; it is the layered, length-bounded search that the RICH algorithm from the graph-algorithms piece is built to run.

So detection does not win you the trade; it only qualifies you to compete for it. The log(gross) > 0 test tells you an opportunity exists — it says nothing about whether you will be the address that captures it. That is decided one layer down, in the ordering, and the ordering is not something your algorithm computes. It is something you bid for. Everything hard about on-chain arbitrage happens after the cycle is found.

Backrunning: the benign form of MEV

Where do these cycles come from in the first place? Overwhelmingly, from other people's transactions. A large swap on a Uniswap pool moves that pool's price away from the broader market; the pool is now mispriced relative to Binance, relative to a Curve pool, relative to Sushiswap; and the act of realigning it is a profitable arbitrage. The searcher who does this places their transaction immediately after the swap that created the dislocation. This is backrunning, and it is the dominant, benign form of on-chain MEV.

Recall the constant-product mechanics from the MEV piece. A pool holds reserves $x, y$ with $x \cdot y = k$ and spot price $P = y/x$. Someone sells a large amount $\Delta x$ of the base asset into it; by the invariant the pool pays out

$\Delta y = \frac{y\,\gamma\,\Delta x}{x + \gamma\,\Delta x}, \qquad \gamma = 0.997,$

and the new spot price is lower — the seller pushed it down. If the external market price is still $P_{\text{ext}}$, the pool now quotes below $P_{\text{ext}}$, and the profit-maximizing backrun buys from the pool exactly until its marginal price rises back to $P_{\text{ext}}$ — that is, until the reserves satisfy $y/x = P_{\text{ext}}$ again. The arbitrageur captures the area between the pool's execution curve and the flat external price — the value the large swap left on the table by moving the pool.

The critical structural fact — the one that puts backrunning on the benign side of the ledger — is that a pure backrun does not degrade the target's execution. It runs strictly after the victim's swap. By the time the backrun executes, the swapper's price is already locked in; nothing the backrunner does can reach back and worsen it. Contrast this with the toxic sandwich from the MEV piece, where a frontrun is inserted before the victim precisely to worsen their fill so the backrun can harvest the enlarged dislocation. Same backrun mechanics, opposite morality: the sandwich manufactures the mispricing at the victim's expense; the benign backrun merely cleans up a mispricing the victim would have created anyway. The arbitrageur is the mechanism by which on-chain prices track the outside world — the same role that makes cross-venue arbitrage a stabilizing force everywhere in finance.

This is also why the modern MEV-protection stack tries to preserve and redistribute backruns while suppressing sandwiches. Flashbots' MEV-Share and order-flow auctions let a user expose partial hints about their transaction, invite searchers to bid for the right to backrun it, and refund most of the resulting profit to the user who created the opportunity. The backrun still happens — the price still gets realigned — but the value flows back to the transaction that generated it instead of being stolen by whoever was fastest.

Where the cycles come from

Almost every profitable cycle is downstream of some other on-chain event that moved a price. Knowing the sources is the difference between polling the whole graph blindly and watching the handful of triggers that actually create edges:

• Large swaps. The canonical source, worked above: any trade big enough to move a pool off the broader market opens a backrun to realign it. The bigger the swap and the thinner the pool, the larger the cycle.
• Oracle updates. Every venue that prices off an oracle — money markets, perp DEXs — becomes arbitrageable the instant the feed moves. The oracle-update backrun that drives liquidations, dissected in the liquidations piece, is this same move applied to a price feed instead of a swap: the update is the starting gun, and the searcher lands immediately behind it.
• New or removed liquidity. A large LP mint or burn shifts a pool's depth and can leave it momentarily off-price; just-in-time (JIT) liquidity is the adversarial version, adding depth around a single pending swap and pulling it immediately after.
• Cross-pool routing residue. A router that splits a swap across pools rarely leaves all of them at exactly the same price, and the small imbalances it leaves are backrun-able cycles.

The practical takeaway: an arbitrage bot is mostly an event listener, not a graph solver. It watches these triggers, recomputes only the sub-graph each one touches, and fires a bundle — which is why the incremental-update design from the graph-algorithms piece matters far more than raw search speed over the full graph.

The auction eats the margin

Now the uncomfortable part. You found the cycle. So did everyone else. The opportunity is deterministic, atomic, and capital-free — which means the only variable left is who lands in the winning slot, and that is settled by a priority auction.

Since the migration to proposer-builder separation and MEV-Boost (the plumbing detailed in the forthcoming MEV supply chain: PBS and MEV-Boost), searchers no longer fight public gas wars in the mempool. They submit bundles privately to block builders, attaching a bid — either as a high priority fee or as a direct payment to the builder. The builder assembles the most valuable block it can and forwards it to the proposer. From the searcher's seat, this is a sealed-bid auction for the right to be the address that executes a known, deterministic prize.

Model it. Let the gross arbitrage profit be $G$ — the $673 from the worked cycle above, say — and let each searcher's cost (gas, flash-loan fee) be $c$. To win the slot, you bid $b$ against every other searcher who computed the same $G$. Your net if you win is

$\pi = G - c - b.$

You want $b$ as low as possible; you also want to win. But your competitors face the identical arithmetic against the identical $G$. In a sealed-bid auction over a common-value prize that everyone can compute exactly, the equilibrium bid climbs until it consumes almost the entire surplus: $b \to G - c - \varepsilon$, and the winner keeps only $\varepsilon$, the razor-thin margin by which they outbid the runner-up. That $673 does not stay with whoever found the cycle; almost all of it is bid straight through to the builder and, ultimately, the proposer who sold the ordering. This is not a market failure; it is what a competitive auction is supposed to do.

The revert is not free — failure-rate economics

There is a second cost the naive model omits, and it is the one that actually separates operators. When you lose the auction, your bundle simply does not land — you pay nothing, which is the whole point of bundle submission over the old public gas wars. But when you win the auction with a bundle whose simulation was stale — the reserves moved between your read and inclusion — your require(end >= start + minProfit) guard fires and the transaction reverts on-chain, and you pay gas for the revert. Atomicity protects your principal, not your gas.

So the searcher's real expected value per opportunity is

$\mathbb{E}[\pi] = p_{\text{win, profitable}}\,(G - c - b)\;-\;p_{\text{win, reverted}}\,g_{\text{revert}},$

where $g_{\text{revert}}$ is the gas burned on a landed-but-reverting bundle. Pushing your bid $b$ higher wins more slots but also wins more stale slots, raising the revert term. The operators who survive are not the ones who find more cycles — everyone finds the same cycles — but the ones with lower $c$ (cheaper, tighter execution paths), lower revert probability (fresher simulation, better inclusion prediction), and the discipline to not bid on marginal opportunities where the expected revert cost swamps the thin surplus. The edge, such as it is, lives entirely in these second-order costs.

The empirical shape matches the model. When many bots simulate the same on-chain opportunity to the same profit figure, the winning bundle routinely tips the large majority of gross profit to the builder and validator — the same 90%-plus leakage we measured for liquidations, for the same reason: perfect information about a common prize plus a sealed-bid auction equals margins competed down to the cost of the marginal loser. The searcher's edge is not the size of $G$, which everyone sees. It is any private advantage in $c$ (cheaper execution, better routing, lower failure rate) or in seeing $G$ before the crowd does.

Which tells you exactly where profit still survives:

• Long-tail chains and immature builder markets. On chains where few sophisticated searchers operate and the builder auction is thin or absent, the bid $b$ stays low because there is no one to bid you up. The same cycle that nets $\varepsilon$ on Ethereum mainnet can net most of $G$ on a quiet L2 or an alt-L1. The edge is competition, not cleverness.
• Low-competition pools and exotic assets. Opportunities whose profitable exit requires eating thin, path-dependent DEX liquidity are hard to simulate correctly. A searcher who models the full round-trip — including exit slippage on an illiquid token — captures cycles that naive bots either miss or misprice into a revert. Here the edge is genuinely execution quality, not latency.
• CEX-DEX arbitrage. The single largest category — and the one that breaks atomicity. It gets its own section, next.

The honest summary of the atomic, on-chain game: it is a superb way to learn EVM internals, builder plumbing, and auction theory the hard way. It is a brutal way to earn a living, because the thing you are selling — the ability to find and execute a deterministic cycle — is exactly the thing your competitors are also selling, and the auction prices it at cost.

CEX-DEX arbitrage: the biggest category, and it is not atomic

The largest single source of extractable value on-chain is not the tidy atomic cycle. It is CEX-DEX arbitrage: the price of an asset on a centralized exchange diverges from its price on a DEX, and a searcher trades both sides to close the gap. Studies of non-atomic arbitrage — most directly Heimbach, Pahari and Schertenleib's Non-Atomic Arbitrage in Decentralized Finance (2024) — attribute on the order of hundreds of millions of dollars of extracted value to cross-exchange arbitrageurs over a multi-year window, exceeding the atomic, purely-on-chain categories. If you want to understand where the money in MEV actually is, this is it.

And it violates the property that made everything above safe. One leg of the trade lives on a centralized exchange; the other lives on-chain. The on-chain leg is atomic — it either lands in a block or reverts — but the CEX leg is a separate order on a separate matching engine, settling on its own timeline. The two legs cannot be wrapped in a single revert. There is no require(end >= start) spanning both venues. The searcher backruns a swap on Uniswap to buy WETH cheap on-chain, and separately sells WETH on Binance to realize the spread — and between those two events, the price can move. CEX-DEX arbitrage carries the very inventory risk that atomic arbitrage eliminates.

That risk changes the whole shape of the business:

• You must pre-position inventory on both venues. You cannot flash-loan the CEX leg. To sell WETH on Binance the instant your on-chain buy confirms, you must already hold WETH on Binance (and quote currency on-chain, and vice versa for the other direction). Capital, which the flash loan banished from atomic arbitrage, comes right back as a hard requirement — inventory sitting on multiple exchanges, exposed.
• You must hedge the open leg. Between the on-chain fill and the CEX fill you are directionally long or short the asset. Serious CEX-DEX operators run this as a continuously delta-managed book: they hedge the exposure on a perpetual future, treat the funding cost of that hedge as a cost of doing business, and manage the basis between spot and perp. This is not a new problem — it is exactly the machinery of cross-exchange funding-rate arbitrage, where the whole game is holding offsetting legs across venues and financing the hedge through funding. CEX-DEX arbitrage is that discipline with one leg pinned to a block.
• The edge is partly informational and structural. Because the CEX price leads the DEX price (centralized order books update continuously; AMM quotes only move when someone trades), a searcher who reads the CEX order book knows which direction the next backrun should go before the on-chain price catches up. And increasingly, the builders themselves internalize this flow: a builder that also runs a CEX-DEX desk can order the block around its own trades. This blurs the line between searcher and builder and is one of the centralizing forces in the MEV supply chain — the entities that see the most order flow and control the most ordering also capture the most non-atomic arbitrage.

So the tradeoff is exactly inverted from the atomic case. Atomic arbitrage is safe (revert-on-loss, no inventory, no capital) but ruthlessly competed (deterministic prize, auction eats the margin). CEX-DEX arbitrage is dangerous (real inventory risk, real capital, a hedge to finance and manage) but far larger and less perfectly contested, precisely because the danger and the capital requirement keep out the bots that can only run the risk-free atomic loop. The extra return is compensation for the extra risk — which is the most ordinary fact in finance, finally reasserting itself on a chain that spent a whole section pretending risk-free money was on the table.

What to take away

Compress the argument to its load-bearing points:

1. Atomicity is the whole safety model. A multi-hop arbitrage is one transaction with a require(end >= start + minProfit) guard; anything that turns it unprofitable reverts, so the arbitrageur never holds mid-cycle inventory risk and never sells the last leg at a loss.
2. Flash loans decouple profit from capital. Borrow, arb, and repay inside one atomic transaction; the lender is protected by the same revert you are. The winner is not the searcher with the most capital — capital is not the moat.
3. Detection is the easy, commoditized half. The negative-cycle search of graph algorithms for arbitrage is deterministic and identical for everyone; finding the cycle only qualifies you to compete for it.
4. Backrunning is the benign, dominant form. Landing immediately after a large swap or an oracle update realigns a mispriced pool without degrading anyone's fill — the opposite of the toxic sandwich, and the thing MEV-Share tries to redistribute rather than suppress.
5. The auction eats almost all of the margin. In a sealed-bid builder auction over a common, computable prize, bids converge to $G - c - \varepsilon$ and 90%-plus leaks to the builder and proposer. Profit survives only where competition is thin: long-tail chains, illiquid pools, and the harder-to-simulate exits.
6. CEX-DEX is the biggest category and it is not atomic. One leg on a CEX means real inventory risk, real capital, and a hedge to finance — the cross-exchange funding playbook applied with one leg pinned to a block, and one of the forces pulling the MEV supply chain toward the builders who see the most flow.

On-chain arbitrage looks, from the outside, like a puzzle about finding hidden cycles. From the inside it is an auction — and the puzzle was solved for everyone at the same instant. Knowing where the cycle is has never been the edge. Winning the slot, or trading where no one else is bidding, always was.

References

• Daian, Goldfeder, Kell, Li, Zhao, Bentov, Breidenbach, Juels (2019), Flash Boys 2.0: Frontrunning, Transaction Reordering, and Consensus Instability in Decentralized Exchanges. arXiv:1904.05234.
• Heimbach, Pahari, Schertenleib (2024), Non-Atomic Arbitrage in Decentralized Finance. arXiv:2401.01622 (IEEE S&P 2024).
• Robinson & Konstantopoulos (2020), Ethereum is a Dark Forest.
• Aave v3 flash loans and Balancer / Uniswap v3 flash-swap documentation (fee schedules).
• Flashbots documentation: MEV-Boost, MEV-Share, order-flow auctions (docs.flashbots.net).