DEV Community

Cover image for Uniswap V2 Decoded: A Complete Guide with Code Examples
Aditya41205
Aditya41205

Posted on

Uniswap V2 Decoded: A Complete Guide with Code Examples

#uniswapv2 #web3 #blockchain #solidity

Uniswap

Uniswap V2 revolutionized decentralized trading by introducing automated market makers (AMMs) that enable permissionless token swapping and liquidity provision. In this comprehensive guide, we'll decode the core mechanics of Uniswap V2 with practical code examples that you can implement today.

Understanding Uniswap V2 Architecture

Uniswap V2 implements a core/periphery architecture that separates essential functionality from user-friendly interfaces. The core contracts handle the fundamental trading logic and secure liquidity pools, while periphery contracts like the Router provide safety checks and ease-of-use features.

Core vs Periphery Design

The minimalist core contracts contain only logic strictly necessary to secure liquidity, while periphery contracts handle trader security and user experience. This modular approach allows external helpers to be improved and replaced without migrating liquidity.

// Core: Minimal, secure, immutable contract UniswapV2Pair { // Essential trading logic only } // Periphery: User-friendly, upgradeable contract UniswapV2Router02 { // Safety checks and convenience functions }
Enter fullscreen mode Exit fullscreen mode

Setting Up Your Contract

To interact with Uniswap V2, you need to create an instance of the router contract:

pragma solidity ^0.8.0; import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; contract UniswapV2Integration { address private constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; IUniswapV2Router02 public uniswapV2Router; constructor() { uniswapV2Router = IUniswapV2Router02(ROUTER); } }
Enter fullscreen mode Exit fullscreen mode

Key Components:

  • Router Address: The official Ethereum mainnet address of UniswapV2Router02
  • Interface Declaration: Defines all available router functions
  • Instance Creation: Enables calling router functions in your contract

Adding Liquidity: Becoming a Liquidity Provider

The addLiquidity() function allows you to provide liquidity to trading pairs and earn fees from every trade.

Function Signature 

function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity);
Enter fullscreen mode Exit fullscreen mode

Parameter Breakdown

  • tokenA/tokenB: Contract addresses of the tokens to pair
  • amountADesired/amountBDesired: Your preferred deposit amounts
  • amountAMin/amountBMin: Minimum amounts (slippage protection)
  • to: Address receiving LP tokens
  • deadline: Transaction expiration timestamp

Practical Implementation 

function addLiquidityToPool( address tokenA, address tokenB, uint256 amountA, uint256 amountB ) external { // Approve router to spend tokens IERC20(tokenA).approve(address(uniswapV2Router), amountA); IERC20(tokenB).approve(address(uniswapV2Router), amountB); // Add liquidity with 5% slippage tolerance uniswapV2Router.addLiquidity( tokenA, tokenB, amountA, amountB, amountA * 95 / 100, // 5% slippage protection amountB * 95 / 100, // 5% slippage protection msg.sender, // LP tokens to caller block.timestamp + 300 // 5 minute deadline ); }
Enter fullscreen mode Exit fullscreen mode

Internal Mechanics: How addLiquidity() Works

Understanding the internal _addLiquidity() function reveals the sophisticated logic behind liquidity provision:

Pair Creation Check 

if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) { IUniswapV2Factory(factory).createPair(tokenA, tokenB); }
Enter fullscreen mode Exit fullscreen mode

Reserve-Based Calculations

For existing pairs, the function maintains price ratios:

amountBOptimal = amountADesired.mul(reserveB) / reserveA; if (amountBOptimal <= amountBDesired) { (amountA, amountB) = (amountADesired, amountBOptimal); } else { amountAOptimal = amountBDesired.mul(reserveA) / reserveB; (amountA, amountB) = (amountAOptimal, amountBDesired); }
Enter fullscreen mode Exit fullscreen mode

CREATE2 Address Calculation

Uniswap V2 uses deterministic addresses for gas efficiency:

pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' ))));
Enter fullscreen mode Exit fullscreen mode

Removing Liquidity: Exiting Your Position

The removeLiquidity() function allows you to withdraw your tokens by burning LP tokens:

function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB);
Enter fullscreen mode Exit fullscreen mode

Implementation Example 

function removeLiquidityFromPool( address tokenA, address tokenB, uint256 liquidityAmount ) external { address pair = IUniswapV2Factory(factory).getPair(tokenA, tokenB); // Approve router to spend LP tokens IERC20(pair).approve(address(uniswapV2Router), liquidityAmount); // Remove liquidity uniswapV2Router.removeLiquidity( tokenA, tokenB, liquidityAmount, 0, // Accept any amount of tokenA 0, // Accept any amount of tokenB msg.sender, block.timestamp + 300 ); }
Enter fullscreen mode Exit fullscreen mode

Token Swapping: The Heart of DeFi Trading

The swapExactTokensForTokens() function enables precise token exchanges:

function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts);
Enter fullscreen mode Exit fullscreen mode

Advanced Swap Implementation 

function swapTokens( address tokenIn, address tokenOut, uint256 amountIn, uint256 slippagePercent ) external { // Approve router IERC20(tokenIn).approve(address(uniswapV2Router), amountIn); // Calculate minimum output with slippage address[] memory path = new address[](2); path[0] = tokenIn; path[1] = tokenOut; uint[] memory amountsOut = uniswapV2Router.getAmountsOut(amountIn, path); uint amountOutMin = amountsOut[1] * (100 - slippagePercent) / 100; // Execute swap uniswapV2Router.swapExactTokensForTokens( amountIn, amountOutMin, path, msg.sender, block.timestamp + 300 ); }
Enter fullscreen mode Exit fullscreen mode

Multi-Hop Swapping

For tokens without direct pairs, Uniswap routes through intermediate tokens:

function multiHopSwap(uint256 amountIn) external { address[] memory path = new address[](3); path[0] = USDC_ADDRESS; // Start with USDC path[1] = WETH_ADDRESS; // Route through WETH path[2] = DAI_ADDRESS; // End with DAI IERC20(USDC_ADDRESS).approve(address(uniswapV2Router), amountIn); uniswapV2Router.swapExactTokensForTokens( amountIn, 0, // Calculate proper minimum in production path, msg.sender, block.timestamp + 300 ); }
Enter fullscreen mode Exit fullscreen mode

LP Token Economics: Understanding Your Returns

When you provide liquidity, you receive ERC-20 LP tokens representing your pool share:

LP Token Characteristics

  • Proportional ownership of the entire pool
  • Fee accumulation from every trade (0.3% in V2)
  • Redeemable for underlying tokens plus earned fees

Profitability Factors 

// Your share calculation uint256 yourPoolShare = (yourLPTokens * 100) / totalLPSupply; uint256 yourTokenAShare = (poolReserveA * yourPoolShare) / 100; uint256 yourTokenBShare = (poolReserveB * yourPoolShare) / 100;
Enter fullscreen mode Exit fullscreen mode

Security Considerations and Best Practices

Always Use Slippage Protection 

// Bad: No slippage protection uniswapV2Router.swapExactTokensForTokens(amountIn, 0, path, to, deadline); // Good: Proper slippage protection uint256 amountOutMin = expectedAmount * 95 / 100; // 5% slippage uniswapV2Router.swapExactTokensForTokens(amountIn, amountOutMin, path, to, deadline);
Enter fullscreen mode Exit fullscreen mode

Implement Proper Deadlines 

// Bad: No deadline uint deadline = type(uint).max; // Good: Reasonable deadline uint deadline = block.timestamp + 300; // 5 minutes
Enter fullscreen mode Exit fullscreen mode

Handle Approvals Securely 

function safeApprove(address token, address spender, uint256 amount) internal { IERC20(token).approve(spender, 0); // Reset to 0 first IERC20(token).approve(spender, amount); }
Enter fullscreen mode Exit fullscreen mode

Complete Integration Example

Here's a comprehensive contract that demonstrates all major Uniswap V2 interactions:

pragma solidity ^0.8.0; import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol"; import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; contract UniswapV2Manager { IUniswapV2Router02 public immutable uniswapV2Router; IUniswapV2Factory public immutable uniswapV2Factory; constructor() { uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uniswapV2Factory = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f); } function addLiquidity( address tokenA, address tokenB, uint256 amountA, uint256 amountB, uint256 slippage ) external returns (uint256, uint256, uint256) { IERC20(tokenA).transferFrom(msg.sender, address(this), amountA); IERC20(tokenB).transferFrom(msg.sender, address(this), amountB); IERC20(tokenA).approve(address(uniswapV2Router), amountA); IERC20(tokenB).approve(address(uniswapV2Router), amountB); uint256 amountAMin = amountA * (100 - slippage) / 100; uint256 amountBMin = amountB * (100 - slippage) / 100; return uniswapV2Router.addLiquidity( tokenA, tokenB, amountA, amountB, amountAMin, amountBMin, msg.sender, block.timestamp + 300 ); } function removeLiquidity( address tokenA, address tokenB, uint256 liquidity, uint256 slippage ) external returns (uint256, uint256) { address pair = uniswapV2Factory.getPair(tokenA, tokenB); IERC20(pair).transferFrom(msg.sender, address(this), liquidity); IERC20(pair).approve(address(uniswapV2Router), liquidity); // Get current reserves to calculate minimums (uint256 reserveA, uint256 reserveB,) = IUniswapV2Pair(pair).getReserves(); uint256 totalSupply = IERC20(pair).totalSupply(); uint256 amountAMin = (reserveA * liquidity / totalSupply) * (100 - slippage) / 100; uint256 amountBMin = (reserveB * liquidity / totalSupply) * (100 - slippage) / 100; return uniswapV2Router.removeLiquidity( tokenA, tokenB, liquidity, amountAMin, amountBMin, msg.sender, block.timestamp + 300 ); } function swapExactTokensForTokens( address tokenIn, address tokenOut, uint256 amountIn, uint256 slippage ) external returns (uint256[] memory) { IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn); IERC20(tokenIn).approve(address(uniswapV2Router), amountIn); address[] memory path = new address[](2); path[0] = tokenIn; path[1] = tokenOut; uint256[] memory amountsOut = uniswapV2Router.getAmountsOut(amountIn, path); uint256 amountOutMin = amountsOut[1] * (100 - slippage) / 100; return uniswapV2Router.swapExactTokensForTokens( amountIn, amountOutMin, path, msg.sender, block.timestamp + 300 ); } }
Enter fullscreen mode Exit fullscreen mode

Conclusion

Uniswap V2's elegant design combines simplicity with powerful functionality. By understanding the core mechanics of liquidity provision, token swapping, and the underlying mathematical models, developers can build sophisticated DeFi applications that leverage automated market makers.

The key to successful Uniswap V2 integration lies in:

  • Proper slippage protection to prevent unfavorable trades
  • Secure token approvals to maintain user fund safety
  • Efficient routing for optimal swap execution
  • Understanding LP economics for sustainable liquidity provision

Whether you're building a DEX aggregator, yield farming protocol, or simple token swap interface, Uniswap V2's battle-tested infrastructure provides the foundation for reliable decentralized trading.

Remember to always test your implementations thoroughly on testnets before deploying to mainnet, and consider the gas costs and user experience implications of your design choices.

Top comments (0)