How Token Swaps Work

The term "token swap" covers a lot of ground. At its simplest, it means exchanging one token for another. But the mechanism behind that exchange varies considerably — depending on whether the swap executes against a pool of reserves, an order book, or an off-chain solver system. The output looks identical from the outside: you sent one token, you received another. The execution path underneath it isn't.

This post explains how swaps actually work mechanically, where the risks sit, and how the execution infrastructure is changing.

The AMM Swap Mechanism

The most common swap mechanism is the Automated Market Maker (AMM). When you swap Token A for Token B on a protocol like Uniswap, you're not matched with another trader — you're trading against a pool of reserves held by a smart contract.

Here's the step-by-step:

1. You submit a transaction specifying: input token, input amount, output token, minimum acceptable output (slippage tolerance), and a deadline.
2. The contract reads the current pool reserves — say, 1,000 ETH and 2,000,000 USDC.
3. The constant product formula governs pricing: x × y = k. The pool must maintain the same product of reserves before and after the trade.
4. You send ETH into the pool. The formula calculates exactly how much USDC must leave to preserve k.
5. That USDC is sent to your address. A trading fee — typically 0.05% to 0.3% depending on the pool — stays in the pool, accruing to liquidity providers.
6. If the actual output falls below your specified minimum due to price movement between when you signed and when the transaction executed, the trade reverts automatically. Gas is still consumed.

The key property: price is a function of pool depth. A swap that represents a small fraction of pool reserves barely moves the price. A large swap shifts the pool ratio significantly, creating price impact — you're buying at progressively worse rates with each incremental unit purchased.

Price Impact vs. Slippage

These are related but distinct concepts that often get conflated.

Price impact is the permanent change to the pool's exchange rate caused by your trade. It's a direct mathematical consequence of trade size relative to pool depth. Double the pool size and you halve the price impact for any given trade.

Slippage is the difference between the price you saw when you initiated the swap and the price you actually received when it executed. This gap opens when other transactions run in the same block and move the pool before yours does — or when MEV activity deliberately positions around your trade.

Setting a tight slippage tolerance (0.1%) protects you from large deviations but increases the chance of reversion. Setting it loose (1%+) guarantees execution but creates exposure to frontrunning.

MEV and the Sandwich Attack

When you submit a swap to the public mempool, it's visible to anyone before it executes. Searchers — automated bots monitoring pending transactions — can see a large pending swap and execute a sandwich around it: buy the same token before your transaction runs (raising the price), let your swap execute at the inflated price, then immediately sell to capture the difference.

The result is you receive less than the quoted rate — but within your specified slippage tolerance, so the transaction doesn't revert. The sandwich is profitable precisely because it stays inside the acceptable band.

This is a structural property of public mempool systems, not a bug. Private mempools, commit-reveal schemes, and intent-based execution emerged partly in response to it.

Routing and Aggregators

Most retail swaps today don't go directly to a single liquidity pool. Aggregators — 1inch, Paraswap, CoW Protocol — split orders across multiple pools and routes to minimize price impact. A swap from a low-liquidity token to another might route through three or four intermediate pairs, hitting separate pools at each hop to find better cumulative execution than any direct path would provide.

The aggregator computes the optimal route at query time and encodes it into the swap transaction. Route quality degrades if prices move significantly between query and execution — which is why the slippage tolerance exists as a backstop, not as a primary control.

Intent-Based Swaps

An alternative architecture has emerged that shifts the execution model entirely. Instead of constructing a specific transaction, users declare an intent: “I want to sell X of Token A for at least Y of Token B, settled by time T.” Solvers — third parties competing for the right to fill the order — find the best execution path, which may include private liquidity, off-chain matching with opposing orders, or cross-chain sources. The winning solver submits the solution on-chain; user funds only move if the specified conditions are met.

CoW Protocol and UniswapX operate on this model. The efficiency gain is real: solver competition can produce better prices than direct routing, and batch execution can eliminate MEV entirely by matching opposing trades internally without touching an on-chain pool. The trade-off is trust and timing — users rely on solver ecosystems being competitive, and settlement is slightly less immediate than direct execution.

Where Constraints Live

Several hard constraints govern all swap execution regardless of the protocol:

• AMM pricing is deterministic once pool reserves are known. Nothing overrides the formula.
• Atomic execution: the trade either completes fully or reverts entirely. No partial fills on AMM pools.
• Gas costs: on Ethereum mainnet, swap transactions carry meaningful fixed overhead. This makes small swaps uneconomical on L1, which drove the migration of retail activity to L2 networks where fees are a fraction of the cost.

Soft constraints that are stable but not absolute:

• Aggregator route quality depends on real-time pool data. Stale quotes create execution risk.
• Intent systems require competitive solver ecosystems. Thin solver markets reduce the execution quality benefit.
• Cross-chain swaps add bridge trust assumptions and introduce settlement lag that single-chain swaps don't have.

What's Changing

The shift from direct pool interaction toward aggregator-routed and intent-based execution represents a genuine architectural change. The swap mechanism is increasingly invisible to end users — the surface is “tell us what you want”; the underlying complexity is absorbed by solver competition and routing logic.

Cross-chain swap infrastructure is also maturing. Protocols like Thorchain enable native BTC-to-ETH swaps without wrapped intermediaries, though at the cost of trusting a separate validator set. Aggregation layers like Li.Fi and Socket abstract multi-chain routing across several bridge protocols simultaneously.

The core mechanism is stable. What's changing is who bears the execution complexity — and increasingly, it's not the user.

Confirmation Signals

Aggregator volume share growing as a proportion of total DEX volume. Intent-based systems capturing meaningful share of large-order flow, producing tighter spreads than equivalent direct routing. Cross-chain swap volume growing without a corresponding increase in bridge exploit frequency.

Invalidation Signals

Discovery of a structural exploit in a major aggregator or intent router contract. Regulatory classification of solver activity as unlicensed dealing or market-making in major jurisdictions. Sustained volume migration away from on-chain execution toward centralized alternatives with better guarantees.

Timing Perspective

Now — AMM-based swaps are live at scale across every major EVM chain and several non-EVM networks. This is the current baseline mechanism. Aggregators have become the default entry point for most retail swaps.

Next (2026) — Intent-based architectures are in active deployment but haven't captured dominant order flow. Solver competition and route quality are the variables to watch as adoption scales.

Later — Cross-chain swap composability without bridge intermediaries at competitive speed and cost remains unresolved. The infrastructure to make it a seamless default doesn't yet exist uniformly across chains.

Boundary Statement

This post explains the swap mechanism. It doesn't constitute guidance on which protocol to use, how to evaluate slippage parameters for a specific trade size, or how to measure MEV exposure in practice. The tracked version — including execution comparison and signal monitoring — lives elsewhere.

The mechanism works as described. Whether it's the right execution path for any specific situation depends on factors outside this scope.