DEX Design: AMMs, Liquidity Pools & Solidity

Learning Goal: "Building a Decentralized Exchange (DEX): Designing Constant Product Market Makers and Liquidity Pools from Scratch"

This curriculum provides an end-to-end blueprint for mastering decentralized exchange design. You will transition from decentralized storage and virtual machines to automated market maker mechanics, the mathematics of Uniswap v2 constant product invariant equations, secure Solidity implementations of core router patterns, and full-stack integration using React, Ethers.js, and Sepolia testnet tools.

• Prerequisites: Basic understanding of programming concepts (variables, functions, loops) and familiarity with web technologies (HTML, JavaScript/React). No prior blockchain or Web3 experience is required.
• Estimated Total Study Time: 24 Hours

---

Module 1: Blockchain & Smart Contract Foundations

Understand how Ethereum, the EVM, and smart contracts function as the foundational infrastructure for decentralized applications. This module establishes a strong mental model of how decentralized consensus engines run programs peer-to-peer.

Recommended Videos

• Why this video: A stellar starting point to conceptualize the shift from Bitcoin's single-utility transaction registry to Vitalik Buterin’s vision of programmable money. It explains dApps and high-level execution pathways using simple analogies.

• Why this video: To build a secure DEX, you must understand the Ethereum Virtual Machine (EVM) architecture. This deep dive breaks down stack-based execution, opcodes, memory management, and how high-level Solidity contract variables are mapped to persistent blockchain storage slots.

• Why this video: A rapid, syntax-focused orientation to Solidity. It introduces statically-typed variable structures, mappings, functions, visibility modifiers, and state changes—allowing you to quickly begin drafting custom contracts.

Knowledge Checkpoint

• Explain the fundamental difference between Bitcoin's UTXO execution model and Ethereum's Account/EVM state machine.
• Differentiate between memory, storage, and calldata data locations in Solidity and write a basic contract displaying correct gas-optimized options.
• Describe how high-level Solidity code compiles into bytecode and how EVM opcodes execute transactions step-by-step.

---

Module 2: DeFi & Automated Market Makers (AMM) Core Concepts

This module transitions you from traditional financial matching structures to peer-to-smart-contract liquidity systems. You will learn the historical limitations of on-chain order books and explore the mechanics of decentralized, automated pools.

Conceptual Deep Dive: Order Books vs. AMMs

Before watching the core material, it is critical to understand the structural paradigm shift in exchange mechanics:

Centralized / Order Book Model: [Buyer: Bids $99] <---> [Matching Engine] <---> [Seller: Asks$101]

• Requires active market makers to maintain narrow spreads.
• Heavy computational overhead; impractical for on-chain state updates.

Decentralized / AMM Model: [Trader] <---> [Liquidity Pool (Smart Contract)] <---> [Liquidity Provider (LP)] * Formula-driven swap execution. * LPs supply assets up front; zero matching counterparty required.

1. Order Book Systems (e.g., Nasdaq, Coinbase):
   • Mechanism: Trade execution relies on an continuous double auction model, where buyers list bids and sellers list asks. Transactions occur when prices cross.
   • On-Chain Viability: High transaction fees (gas) and low block throughput make traditional order books economically non-viable on-chain. Maintaining, canceling, and updating order states requires continuous, expensive transactions.
2. Automated Market Makers (AMMs):
   • Mechanism: Swapping relies on mathematical pricing curves ($xy=k$) managed directly inside a smart contract. Traders interact directly with a pool of tokens instead of a specific counterparty.
   • On-Chain Viability: Extremely lightweight. A swap transaction requires only a single state-changing transaction, making decentralized trading highly efficient on the EVM.

Recommended Videos

• Why this video: This video addresses the comparison gap directly. It details why matching-engine-driven order books fail under high-latency, gas-constrained layer-1 blockchain networks, and highlights why AMMs are the ideal alternative.

• Why this video: This whiteboard animation breaks down the anatomy of a liquidity pool. It details how ordinary users act as market makers (liquidity providers), how they receive fees, and how pool balance is maintained.

• Why this video: A comparative breakdown of the decentralized exchange landscape. It shows how Uniswap's constant product formula compares with Curve’s stableswap invariant and Balancer’s multi-asset weighted formulas, demonstrating how different mathematical models solve specific liquidity issues.

Knowledge Checkpoint

• Diagram the operational differences between an order book matching engine and an automated market maker.
• Explain how a liquidity pool contract determines the initial exchange rate of two unseeded tokens.
• Define how LP tokens represent ownership of a pool's underlying assets and how fees accrue to LPs.

---

Module 3: The Math of Constant Product Market Makers ($xy = k$)

Learn the mathematical frameworks governing decentralized exchanges, pricing mechanics, and the trade-offs of AMM mechanics.

Math Derivation: Slippage and Price Impact

Let us mathematically derive the price impact formula for a constant product liquidity pool.

Suppose a pool contains reserves of two tokens, $X$ and $Y$, governed by the constant product invariant: $x \cdot y = k$

When a trader swaps $\Delta x$ of Token $X$ into the pool, they receive $\Delta y$ of Token $Y$. The constant $k$ must remain unchanged: $(x + \Delta x)(y - \Delta y) = k$

Since $k = x \cdot y$, we can substitute it into the equation: $(x + \Delta x)(y - \Delta y) = x \cdot y$ $x \cdot y - x \cdot \Delta y + y \cdot \Delta x - \Delta x \cdot \Delta y = x \cdot y$ $y \cdot \Delta x = \Delta y (x + \Delta x)$

Solving for $\Delta y$ (the output amount of Token $Y$ received): $\Delta y = \frac{y \cdot \Delta x}{x + \Delta x}$

Spot Price vs. Effective Price

• Spot Price ($P_{spot}$): The marginal exchange rate in an infinitely small trade. $P_{spot} = \frac{y}{x}$
• Effective Price ($P_{eff}$): The actual exchange rate executed for the swap of size $\Delta x$. $P_{eff} = \frac{\Delta y}{\Delta x} = \frac{y}{x + \Delta x}$

Price Impact Formula

Price Impact ($PI$) measures the percentage difference between the starting spot price and the actual execution price: $PI = \frac{P_{spot} - P_{eff}}{P_{spot}} = 1 - \frac{P_{eff}}{P_{spot}}$

Substitute the equations for $P_{spot}$ and $P_{eff}$: $PI = 1 - \frac{\frac{y}{x + \Delta x}}{\frac{y}{x}} = 1 - \frac{x}{x + \Delta x}$ $PI = \frac{(x + \Delta x) - x}{x + \Delta x} = \frac{\Delta x}{x + \Delta x}$

Thus, the price impact of a trade is directly proportional to the size of the trade ($\Delta x$) relative to the size of the pool reserves ($x + \Delta x$). Larger trades drive the pool further along the constant product curve, leading to higher price impact.

---

Recommended Videos

• Why this video: This video provides a step-by-step breakdown of how to solve the constant product swap equations. It details how the relationship between reserves dictates trade execution, helping you translate theoretical math into code.

• Why this video: This video explains how pricing changes dynamically dynamically during swap operations. It teaches how arbitrary price movements in external markets are corrected within the pool via arbitrage traders.

• Why this video: A clear, visual breakdown of Impermanent Loss (IL). It contrasts holding tokens in a wallet versus providing liquidity to an AMM when asset prices diverge, making it easy to understand the math behind IL calculations.

Knowledge Checkpoint

• Perform a manual pen-and-paper calculation of the output amount ($\Delta y$) when swapping $10$ units of $X$ into a pool with $x = 100$ and $y = 500$.
• Derive the percentage of Impermanent Loss experienced if the market price ratio of your pooled assets shifts by a factor of 2.
• Differentiate between Price Impact (the mathematical consequence of the constant product curve) and Slippage (the difference between expected execution price and actual execution price due to frontrunning or block-inclusion delays).

---

Module 4: Coding a DEX from Scratch in Solidity

This module guides you through building a functional, constant product AMM smart contract. You will implement standard ERC20 token interactions, safety checks, swap execution paths, and liquidity management functions.

ERC20 Token Approvals & Security in DEX Architecture

When writing decentralized exchanges, failure to handle standard token transfers secure and correctly is a common vector for smart contract vulnerabilities and exploits.

A decentralized exchange typically splits its architecture into two parts:

1. Core Factory/Pair Contracts: This contract holds the actual reserves of tokens ($X$ and $Y$). It is designed to be highly gas-efficient and performs low-level actions.
2. Router Contracts: This contract is the user-facing entry point. It handles complex routing logic, multi-hop swaps, and calculates expected inputs/outputs.

The "Approve and TransferFrom" Design Pattern

Because users interact with the Router to trade, but the Pair contract holds the reserves, the Router must have permission to transfer tokens on the user's behalf. This requires a two-step transaction process:

[User Wallet] --(Tx 1: Approve)--> [ERC20 Token Contract]

• User authorizes the Router to spend up to 'N' tokens on their behalf.
• Updates the ERC20 contract's 'allowance' state mapping.

[User Wallet] --(Tx 2: Swap)-----> [DEX Router Contract] --(transferFrom)--> [DEX Pair Contract]

• Router calls token.transferFrom(msg.sender, pairAddress, amount)
• ERC20 contract verifies the allowance, transfers tokens, and updates balances.

If a swap is executed without first checking the user's approval allowance, or if a contract attempts to transfer tokens without verifying the return values of transferFrom (or using SafeERC20), transactions can fail silently. This can lead to uncollateralized swaps or lost funds.

---

Recommended Videos

• Why this video: Essential security training. It explains how to interact with third-party ERC20 contracts from within your own contracts, detailing how to safely handle allowances and execute transferFrom functions.

• Why this video: An in-depth, line-by-line walk-through of the Uniswap v2 core code. It details the precise implementation of the mint, burn, and swap functions, showing how to maintain mathematical safety guarantees.

• Why this video: This video covers how to write a router contract that interfaces with Uniswap's core. It explains how to programmatically calculate reserves and execute swaps using high-level logic.

Knowledge Checkpoint

• Write a secure Solidity function that executes a token swap while enforcing a user-defined minimum output parameter (amountOutMin) to prevent sandwich attacks.
• Explain why the core Uniswap v2 pair contract relies on low-level transfer and balance checks rather than calling higher-level router transfer patterns directly.
• Implement a custom LP token ERC-20 inheritance structure that mints and burns shares on deposit and withdrawal.

---

Module 5: Frontend Integration & Deployment

Deploy your smart contracts and connect them to a web interface, enabling users to swap tokens and manage liquidity pools.

Recommended Videos

• Why this video: A detailed integration tutorial. This guide covers how to establish a clean Web3 provider connection using Ethers.js within React, manage wallet connections, and handle asynchronous user transaction states.

• Why this video: This video provides a structured guide to linking your compiled Solidity contract ABIs with a React frontend. It teaches you how to map contract events directly to user interface state updates.

• Why this video: A practical, step-by-step guide to deploying contracts onto the Sepolia Ethereum testnet. It walks through compiling, managing private keys safely, using a faucet, and verifying your contract code on Etherscan.

Knowledge Checkpoint

• Connect a React application to a browser wallet using Web3Modal or Ethers.js providers.
• Fetch the current token reserves of your DEX smart contract and display the updated exchange price on a web frontend.
• Deploy your core DEX contract onto the Sepolia test network and successfully verify it on Etherscan.

---

Course Map

This flowchart maps the recommended learning path and module dependencies for this course:

---

Key People Index

• Vitalik Buterin (Co-founder of Ethereum): Proposed the core concept of automated market makers on-chain in 2016, paving the way for today's AMM platforms.
• Gavin Wood (Co-founder of Ethereum): Designed the yellow paper and specified the virtual machine (EVM) execution engine.
• Hayden Adams (Founder of Uniswap): Translated the constant product concept into the Uniswap protocol, launching the decentralized finance (DeFi) ecosystem.
• Patrick Collins (Blockchain Educator): Developed comprehensive, open-source Web3 security curricula, teaching developers how to write secure, production-ready smart contracts.

---

Final Self-Assessment

Complete these tasks to verify you have met the core learning goals of this curriculum:

• Explain how gas execution fees are calculated for an on-chain transaction.
• List the primary technical and economic reasons why on-chain automated market makers replaced traditional matching engines on Ethereum.
• Derive the constant product formula ($xy = k$) and write out the equation used to calculate price impact for a swap transaction.
• Calculate the expected impermanent loss for a pool where the price of one asset rises by 100% while the other remains flat.
• Code a functional ERC-20 token contract that implements approval and transfer mechanics using OpenZeppelin standards.
• Write a secure Solidity swap contract that prevents reentrancy attacks during swap execution.
• Explain the security risks of using msg.sender inside a nested ERC20 routing context.
• Write a script that deploys a smart contract to the Sepolia testnet using Hardhat or Foundry.
• Read smart contract state variables (such as token balances and pool reserves) using Ethers.js.
• Submit an on-chain transaction through a Web3 wallet from a React frontend interface.