How Uniswap actually works — AMM system design

Traditional financial systems rely on an Order Book model. Buyers submit bid orders ("I want to buy 1 ETH for $3,000") and sellers submit ask orders. A centralized matching engine matches these bids and asks in real-time.

On a public blockchain, running a matching engine is impossible. The computational complexity of maintaining an order book — with constant updates, cancellations, and matching runs — would consume gigabytes of gas, freezing the network.

Uniswap bypassed this entire order book model by inventing the Automated Market Maker (AMM) system design.

Instead of matching individual buyers and sellers, Uniswap pools tokens together in smart contracts (Liquidity Pools) and allows traders to swap directly against the contract using a simple mathematical invariant: Constant Product Formula.

1. The Math: Constant Product (x * y = k)

A Uniswap pool contains balances of two tokens, which we will call x and y (for example, ETH and USDC).

The fundamental invariant governing the pool is:

x * y = k

Where:

• x is the reserve balance of Token A (ETH).
• y is the reserve balance of Token B (USDC).
• k is a constant invariant. This value must remain unchanged during swaps (ignoring fees).

   TRADITIONAL ORDER BOOK MATCHING:
   [ Buyer Bid ] ──┐
                   ├──► [ Matching Engine ] ──► Settlement on Ledger
   [ Seller Ask ] ─┘    (Centralized server / High gas cost on-chain)

   UNISWAP LIQUIDITY POOL (AMM):
                        [ Trader ]
                            │
              Swap dX ETH   │   Get dY USDC
                            ▼
                  +───────────────────+
                  |  UNI-V2 POOL      |
                  |  ETH (x)  USDC (y)|  <── Invariant: x * y = k
                  +───────────────────+

When a trader swaps Token A for Token B:

1. They deposit a quantity delta_x into the contract.

2. The reserve of Token A becomes x + delta_x.

3. To keep k constant, the contract computes the new reserve of Token B (y - delta_y) such that:

   (x + delta_x) * (y - delta_y) = k

4. Rearranging the formula, the trader receives delta_y tokens:

   delta_y = y - (k / (x + delta_x)) = (y * delta_x) / (x + delta_x)

This ensures that as a token becomes scarcer in the pool, its relative price automatically increases, creating a natural supply-and-demand curve inside the code.

2. The Architecture: Factories and Pairs

Uniswap V2 is designed around two primary contracts: the Factory and the Pair (Pool).

            +──────────────────────────────────────+
            |          UNISWAP V2 FACTORY          |
            |                                      |
            |   createPair(tokenA, tokenB) ────────┼────────┐
            +──────────────────────────────────────+        │
                                                            ▼ (Deploys new clone)
                                           +─────────────────────────────────+
                                           |        UNISWAP V2 PAIR          |
                                           |                                 |
                                           |   Reserves: x, y                |
                                           |   swap(amountOutA, amountOutB)  |
                                           |   mint() / burn()               |
                                           +─────────────────────────────────+

• The Factory Contract: Serves as the registry. It keeps a mapping of token pairs to their deployed pool contract addresses. If you want to swap a new ERC-20 token, you call createPair() on the factory, which deploys a new pool contract using deterministic CREATE2 opcodes.
• The Pair Contract: The actual custody engine. It holds the physical reserves of the two tokens and exposes functions for swapping, depositing liquidity (mint), and withdrawing liquidity (burn).

3. Price Slippage and Arbitrage Boundaries

Because Uniswap prices assets based purely on internal ratios (x / y), it does not use a pricing oracle. The pool has no idea what the "real" price of ETH is in the outside world (e.g. on Binance).

If a trader makes a massive purchase of ETH from the pool, they push the reserve ratio out of balance, resulting in Price Slippage. The price of ETH inside the pool rises far above the external market rate.

This creates an Arbitrage opportunity:

1. Arbitrage bots spot the price discrepancy.
2. They buy ETH cheaper on Binance.
3. They swap it for USDC in the Uniswap pool, pocketing the difference.
4. This action pushes the reserves back into balance, aligning the pool price with global market value.

Arbitrage is not an exploit; it is the design boundary that forces decentralized AMMs to track real-world asset prices.