Разработка децентрализованной биржи (DEX)

Разработка DEX (децентрализованной биржи)

Децентрализованная биржа — это smart contracts, которые позволяют торговать без посредника. Пользователь никогда не передаёт контроль над средствами третьей стороне: all trades happen on-chain, settlement атомарный, custody — в кошельке пользователя. Uniswap V3 торгует > $1B в день. Задача: разработать DEX с нуля — от AMM механизма до фронтенда.

Выбор модели DEX

AMM (Automated Market Maker)

Ликвидность предоставляется в пулы, а не в order book. Цена определяется математической формулой.

Constant Product (x * y = k) — Uniswap V2 модель. Простая, работает для любой пары. Недостаток: capital inefficiency — большинство ликвидности никогда не используется.

Concentrated Liquidity — Uniswap V3 модель. LP указывает диапазон цен для своей ликвидности. Capital efficiency в 10–100× выше. Сложнее для LP — нужно активное управление.

Stableswap (Curve) — для активов с похожей ценой (USDC/USDT, stETH/ETH). Минимальный slippage при больших объёмах.

Order Book DEX

On-chain order book — дорогой по газу (каждое размещение/отмена = транзакция). Решения: off-chain orderbook с on-chain settlement (dYdX v3, Serum), или L2-based CLOB (dYdX v4 на Cosmos).

Для большинства DEX на EVM — AMM с concentrated liquidity.

Constant Product AMM: смарт-контракт

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

contract ConstantProductPool is ERC20 {
    address public immutable token0;
    address public immutable token1;
    
    uint256 private reserve0;
    uint256 private reserve1;
    
    uint256 private constant FEE_NUMERATOR = 997;   // 0.3% fee
    uint256 private constant FEE_DENOMINATOR = 1000;
    
    event Swap(address indexed sender, uint256 amount0In, uint256 amount1In,
               uint256 amount0Out, uint256 amount1Out, address indexed to);
    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
    
    constructor(address _token0, address _token1) ERC20("LP Token", "LP") {
        token0 = _token0;
        token1 = _token1;
    }
    
    // Добавление ликвидности
    function mint(address to) external returns (uint256 liquidity) {
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        uint256 balance1 = IERC20(token1).balanceOf(address(this));
        uint256 amount0 = balance0 - reserve0;
        uint256 amount1 = balance1 - reserve1;
        
        uint256 totalSupply_ = totalSupply();
        
        if (totalSupply_ == 0) {
            // Первое добавление ликвидности: геометрическое среднее минус MINIMUM_LIQUIDITY
            liquidity = Math.sqrt(amount0 * amount1) - 1000;
            _mint(address(0xdead), 1000); // заблокировать минимум для предотвращения инфляционной атаки
        } else {
            liquidity = Math.min(
                amount0 * totalSupply_ / reserve0,
                amount1 * totalSupply_ / reserve1
            );
        }
        
        require(liquidity > 0, "INSUFFICIENT_LIQUIDITY_MINTED");
        _mint(to, liquidity);
        
        reserve0 = balance0;
        reserve1 = balance1;
        
        emit Mint(msg.sender, amount0, amount1);
    }
    
    // Вывод ликвидности
    function burn(address to) external returns (uint256 amount0, uint256 amount1) {
        uint256 liquidity = balanceOf(address(this));
        uint256 totalSupply_ = totalSupply();
        
        amount0 = liquidity * reserve0 / totalSupply_;
        amount1 = liquidity * reserve1 / totalSupply_;
        
        require(amount0 > 0 && amount1 > 0, "INSUFFICIENT_LIQUIDITY_BURNED");
        
        _burn(address(this), liquidity);
        IERC20(token0).transfer(to, amount0);
        IERC20(token1).transfer(to, amount1);
        
        reserve0 = IERC20(token0).balanceOf(address(this));
        reserve1 = IERC20(token1).balanceOf(address(this));
        
        emit Burn(msg.sender, amount0, amount1, to);
    }
    
    // Swap
    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external {
        require(amount0Out > 0 || amount1Out > 0, "INSUFFICIENT_OUTPUT_AMOUNT");
        require(amount0Out < reserve0 && amount1Out < reserve1, "INSUFFICIENT_LIQUIDITY");
        
        // Оптимистичный transfer (flash loan паттерн)
        if (amount0Out > 0) IERC20(token0).transfer(to, amount0Out);
        if (amount1Out > 0) IERC20(token1).transfer(to, amount1Out);
        
        // Flash loan callback если нужен
        if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
        
        uint256 balance0 = IERC20(token0).balanceOf(address(this));
        uint256 balance1 = IERC20(token1).balanceOf(address(this));
        
        uint256 amount0In = balance0 > reserve0 - amount0Out ? balance0 - (reserve0 - amount0Out) : 0;
        uint256 amount1In = balance1 > reserve1 - amount1Out ? balance1 - (reserve1 - amount1Out) : 0;
        
        require(amount0In > 0 || amount1In > 0, "INSUFFICIENT_INPUT_AMOUNT");
        
        // Проверяем инвариант с учётом fee: (x + 0.997*dx)(y - dy) >= x*y
        uint256 balance0Adjusted = balance0 * FEE_DENOMINATOR - amount0In * (FEE_DENOMINATOR - FEE_NUMERATOR);
        uint256 balance1Adjusted = balance1 * FEE_DENOMINATOR - amount1In * (FEE_DENOMINATOR - FEE_NUMERATOR);
        
        require(
            balance0Adjusted * balance1Adjusted >= reserve0 * reserve1 * FEE_DENOMINATOR ** 2,
            "K_INVARIANT_VIOLATED"
        );
        
        reserve0 = uint256(balance0);
        reserve1 = uint256(balance1);
        
        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
    }
    
    // Вычисление выходного количества по формуле AMM
    function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) 
        public pure returns (uint256) 
    {
        require(amountIn > 0, "INSUFFICIENT_INPUT_AMOUNT");
        require(reserveIn > 0 && reserveOut > 0, "INSUFFICIENT_LIQUIDITY");
        
        uint256 amountInWithFee = amountIn * FEE_NUMERATOR;
        uint256 numerator = amountInWithFee * reserveOut;
        uint256 denominator = reserveIn * FEE_DENOMINATOR + amountInWithFee;
        
        return numerator / denominator;
    }
}

Factory и Router

Uniswap-style архитектура: Factory создаёт пулы, Router — точка входа для пользователей.

contract DEXFactory {
    mapping(address => mapping(address => address)) public getPool;
    address[] public allPools;
    
    event PoolCreated(address indexed token0, address indexed token1, address pool);
    
    function createPool(address tokenA, address tokenB) external returns (address pool) {
        require(tokenA != tokenB, "IDENTICAL_ADDRESSES");
        
        (address token0, address token1) = tokenA < tokenB 
            ? (tokenA, tokenB) : (tokenB, tokenA);
        
        require(token0 != address(0), "ZERO_ADDRESS");
        require(getPool[token0][token1] == address(0), "POOL_EXISTS");
        
        bytes memory bytecode = type(ConstantProductPool).creationCode;
        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
        assembly { pool := create2(0, add(bytecode, 32), mload(bytecode), salt) }
        
        ConstantProductPool(pool).initialize(token0, token1);
        
        getPool[token0][token1] = pool;
        getPool[token1][token0] = pool;
        allPools.push(pool);
        
        emit PoolCreated(token0, token1, pool);
    }
}

Router: находит путь обмена (прямой или через промежуточный токен — например, TOKEN_A → ETH → TOKEN_B):

contract DEXRouter {
    address public immutable factory;
    address public immutable WETH;
    
    // Swap с slippage protection
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,  // минимальный out — защита от slippage
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts) {
        require(deadline >= block.timestamp, "EXPIRED");
        
        amounts = getAmountsOut(amountIn, path);
        require(amounts[amounts.length - 1] >= amountOutMin, "INSUFFICIENT_OUTPUT_AMOUNT");
        
        IERC20(path[0]).transferFrom(msg.sender, getPool(path[0], path[1]), amounts[0]);
        _swap(amounts, path, to);
    }
    
    // ETH → Token через WETH
    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts) {
        require(path[0] == WETH, "INVALID_PATH");
        amounts = getAmountsOut(msg.value, path);
        require(amounts[amounts.length - 1] >= amountOutMin, "INSUFFICIENT_OUTPUT_AMOUNT");
        
        IWETH(WETH).deposit{value: amounts[0]}();
        IERC20(WETH).transfer(getPool(path[0], path[1]), amounts[0]);
        _swap(amounts, path, to);
    }
}

Безопасность AMM

Reentrancy Protection

// Все внешние вызовы после обновления state (Checks-Effects-Interactions)
// + ReentrancyGuard от OpenZeppelin
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract ConstantProductPool is ERC20, ReentrancyGuard {
    function swap(...) external nonReentrant {
        // ...
    }
}

Price Manipulation (TWAP)

Spot price легко manipulate через flash loan на один блок. Для oracle — Time-Weighted Average Price:

// TWAP oracle — среднее за последние N секунд
uint256 price0CumulativeLast;
uint256 price1CumulativeLast;
uint32  blockTimestampLast;

function _updatePriceAccumulators() private {
    uint32 blockTimestamp = uint32(block.timestamp);
    uint32 timeElapsed = blockTimestamp - blockTimestampLast;
    
    if (timeElapsed > 0 && reserve0 != 0 && reserve1 != 0) {
        // Накапливаем price * time
        price0CumulativeLast += uint256(UQ112x112.encode(reserve1).uqdiv(reserve0)) * timeElapsed;
        price1CumulativeLast += uint256(UQ112x112.encode(reserve0).uqdiv(reserve1)) * timeElapsed;
    }
    
    blockTimestampLast = blockTimestamp;
}

MEV Protection

Frontrunning атаки на DEX — стандартная проблема. Mitigation:

• Slippage tolerance: пользователь устанавливает max slippage (0.5–1%), транзакция реверсируется если превышен
• Deadline: транзакция реверсируется если не исполнена до deadline
• Flashbots / private mempool: для больших свапов — отправка через Flashbots для предотвращения frontrunning

Frontend DEX интерфейс

import { useAccount, useReadContract, useWriteContract } from 'wagmi';
import { parseEther, formatEther } from 'viem';

function SwapInterface() {
  const [tokenIn, setTokenIn] = useState<Token>(ETH);
  const [tokenOut, setTokenOut] = useState<Token>(USDC);
  const [amountIn, setAmountIn] = useState('');
  
  // Получаем quote из контракта
  const { data: amountOut } = useReadContract({
    address: ROUTER_ADDRESS,
    abi: routerAbi,
    functionName: 'getAmountsOut',
    args: amountIn ? [
      parseEther(amountIn),
      [tokenIn.address, tokenOut.address],
    ] : undefined,
    query: { enabled: !!amountIn && parseFloat(amountIn) > 0 },
  });
  
  const { writeContract, isPending } = useWriteContract();
  
  const handleSwap = () => {
    const deadline = Math.floor(Date.now() / 1000) + 1200; // +20 min
    const minAmountOut = amountOut[1] * 995n / 1000n;      // 0.5% slippage
    
    writeContract({
      address: ROUTER_ADDRESS,
      abi: routerAbi,
      functionName: 'swapExactETHForTokens',
      args: [minAmountOut, [WETH, tokenOut.address], account.address, deadline],
      value: parseEther(amountIn),
    });
  };
  
  return (
    <div>
      <TokenInput token={tokenIn} amount={amountIn} onChange={setAmountIn} />
      <SwapArrow onClick={switchTokens} />
      <TokenInput token={tokenOut} amount={amountOut ? formatEther(amountOut[1]) : ''} readonly />
      <PriceImpact amountIn={amountIn} amountOut={amountOut} pool={currentPool} />
      <SlippageSettings />
      <Button onClick={handleSwap} disabled={isPending}>
        {isPending ? 'Swapping...' : 'Swap'}
      </Button>
    </div>
  );
}

Subgraph для аналитики

The Graph — индексация on-chain событий для аналитики:

// schema.graphql
type Pool @entity {
  id: ID!
  token0: Token!
  token1: Token!
  reserve0: BigDecimal!
  reserve1: BigDecimal!
  totalSupply: BigDecimal!
  swapCount: BigInt!
  volumeUSD: BigDecimal!
  createdAt: BigInt!
}

type Swap @entity(immutable: true) {
  id: ID!
  pool: Pool!
  amount0In: BigDecimal!
  amount1In: BigDecimal!
  amount0Out: BigDecimal!
  amount1Out: BigDecimal!
  amountUSD: BigDecimal!
  timestamp: BigInt!
  sender: Bytes!
}

// mapping.ts — обработчик событий
export function handleSwap(event: SwapEvent): void {
  let pool = Pool.load(event.address.toHex())!;
  
  let swap = new Swap(event.transaction.hash.toHex() + "-" + event.logIndex.toString());
  swap.pool = pool.id;
  swap.amount0In = convertTokenToDecimal(event.params.amount0In, pool.token0.decimals);
  swap.amount1In = convertTokenToDecimal(event.params.amount1In, pool.token1.decimals);
  swap.amountUSD = calculateUSDValue(swap, pool);
  swap.timestamp = event.block.timestamp;
  swap.save();
  
  pool.swapCount = pool.swapCount.plus(BigInt.fromI32(1));
  pool.volumeUSD = pool.volumeUSD.plus(swap.amountUSD);
  pool.save();
}

Аудит

DEX smart contracts управляют реальными средствами пользователей. Аудит — не опциональный шаг:

• Reentrancy: все пути исполнения через nonReentrant
• Flash loan attacks: price oracle не использует spot price
• Integer overflow/underflow: Solidity 0.8+ с встроенными проверками
• Access control: только factory может создавать пулы
• Precision loss: integer math, правильный порядок операций

Рекомендуемые аудиторы: Trail of Bits, OpenZeppelin Security, Halborn.

Сроки разработки

MVP DEX на mainnet: 4–6 месяцев с учётом аудита.