The Main Smart Contracts

• UniswapV2ERC20 — an extended ERC20 implementation that's used for LP-tokens. It additionally implements EIP-2612 to support off-chain approval of transfers.
• UniswapV2Factory — similarly to V1, this is a factory contract that creates pair contracts and serves as a registry for them. The registry uses create2 to generate pair addresses — we'll see how it works in detail.
• UniswapV2Pair — the main contract that's responsible for the core logic. It's worth noting that the factory allows to create only unique pairs to not dilute liquidity.
• UniswapV2Router — the main entry point for the Uniswap UI and other web and decentralized applications working on top of Uniswap.
• UniswapV2Library — a collection of helper functions that implement important calculations.

UniswapV2Router02.sol

1address private constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
2
3IUniswapV2Router02 public uniswapV2Router;
4uniswapV2Router = IUniswapV2Router02(ROUTER);

FUNCTION addLiquidity()

1function addLiquidity(
2    address tokenA,
3    address tokenB,
4    uint amountADesired,
5    uint amountBDesired,
6    uint amountAMin,
7    uint amountBMin,
8    address to,
9    uint deadline
10) external returns (uint amountA, uint amountB, uint liquidity);

• tokenA and tokenB: are the tokens we need to get or create the pair we want to add liquidity to.
• amountADesired and amountBDesired are the amounts we want to deposit into the liquidity pool.
• amountAMin and amountBMin are the minimal amounts we want to deposit.
• to address is the address that receives LP-tokens.
• deadline, would most commonly be the block.timestamp

1if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
2    IUniswapV2Factory(factory).createPair(tokenA, tokenB);
3}

1IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves()

1amountBOptimal = amountADesired.mul(reserveB) / reserveA;

1(uint amountA, uint amountB) = (amountADesired, amountBOptimal)

1(uint amountA, uint amountB) = (amountAOptimal, amountBDesired)

1pair = address(uint(keccak256(abi.encodePacked(
2    hex'ff',
3    factory,
4    keccak256(abi.encodePacked(token0, token1)),
5    hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
6))));

1address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);

1liquidity = IUniswapV2Pair(pair).mint(to);

1uint balance0 = IERC20(token0).balanceOf(address(this));
2uint balance1 = IERC20(token1).balanceOf(address(this));

FUNCTION removeLiquidity()

1function removeLiquidity(
2    address tokenA,
3    address tokenB,
4    uint liquidity,
5    uint amountAMin,
6    uint amountBMin,
7    address to,
8    uint deadline
9) external returns (uint amountA, uint amountB);

1IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity);

1amount0 = liquidity.mul(balance0) / _totalSupply;
2amount1 = liquidity.mul(balance1) / _totalSupply;

1_safeTransfer(_token0, to, amount0);
2_safeTransfer(_token1, to, amount1);

1IUniswapV2Pair(pair).burn(to)

FUNCTION swapExactTokensForTokens()

1function swapExactTokensForTokens(
2    uint amountIn,
3    uint amountOutMin,
4    address[] calldata path,
5    address to,
6    uint deadline
7) external returns (uint[] memory amounts);

1TransferHelper.safeTransferFrom()

1_safeTransfer(_token, to, amountOut);

UniswapV2Factory.sol

This contract is a registry of all deployed pair contracts

1address[] public allPairs;

1allPairs.push(pair);

This contract is necessary because we don't want to have pairs of identical tokens

1mapping(address => mapping(address => address)) public getPair;

1require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS');

The contract also simplifies pair contracts deployment

1bytes memory bytecode = type(UniswapV2Pair).creationCode;
2bytes32 salt = keccak256(abi.encodePacked(token0, token1));
3assembly {
4    pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
5}

1function createPair(
2  address tokenA,
3  address tokenB
4) external returns (address pair)

Practical Examples

1function addLiquidity(
2  address _tokenA,
3  address _tokenB,
4  uint _amountA,
5  uint _amountB
6) external {
7  IERC20(_tokenA).transferFrom(msg.sender, address(this), _amountA);
8  IERC20(_tokenB).transferFrom(msg.sender, address(this), _amountB);
9
10  IERC20(_tokenA).approve(ROUTER, _amountA);
11  IERC20(_tokenB).approve(ROUTER, _amountB);
12
13  (uint amountA, uint amountB, uint liquidity) =
14    IUniswapV2Router(ROUTER).addLiquidity(
15      _tokenA,
16      _tokenB,
17      _amountA,
18      _amountB,
19      1,
20      1,
21      address(this),
22      block.timestamp
23    );
24
25  emit Log("amountA", amountA);
26  emit Log("amountB", amountB);
27  emit Log("liquidity", liquidity);
28}

1function removeLiquidity(address _tokenA, address _tokenB) external {
2  address pair = IUniswapV2Factory(FACTORY).getPair(_tokenA, _tokenB);
3
4  uint liquidity = IERC20(pair).balanceOf(address(this));
5  IERC20(pair).approve(ROUTER, liquidity);
6
7  (uint amountA, uint amountB) =
8    IUniswapV2Router(ROUTER).removeLiquidity(
9      _tokenA,
10      _tokenB,
11      liquidity,
12      1,
13      1,
14      address(this),
15      block.timestamp
16    );
17
18  emit Log("amountA", amountA);
19  emit Log("amountB", amountB);
20}

Get in touch

• AMM & DEX audits — Full review of pair contracts, factory logic, and router security
• Fuzz & invariant testing — Foundry-based test suites targeting price manipulation and reserve imbalances
• Fork security reviews — Identify what changed from the original and what risks those changes introduced
• Smart contract development — Secure-by-design implementations optimized for gas efficiency

Glossary