Разработка системы автолистинга на DEX при достижении капитализации

Разработка системы автолистинга на DEX при достижении капитализации

Задача: токен продаётся на presale, и при достижении определённой суммы (hardcap или softcap) ликвидность автоматически листится на Uniswap или аналогичном DEX — без ручного вмешательства команды. Это убирает человеческий фактор и rug pull риск: команда не может «задержать» добавление ликвидности или добавить её на невыгодных условиях.

Механика: как это работает

Смарт-контракт presale держит собранные средства (ETH или USDC) в escrow. При выполнении условия (достигнут target) — автоматически вызывает Uniswap Router для создания пула и добавления ликвидности. LP токены (доказательство ликвидности) отправляются на lock контракт или сжигаются, чтобы ликвидность нельзя было вывести.

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable2Step.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

interface IUniswapV2Router02 {
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    
    function factory() external pure returns (address);
}

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}

contract AutoListingPresale is Ownable2Step, ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    IERC20 public immutable token;
    IUniswapV2Router02 public immutable router;
    
    uint256 public immutable softCap;           // минимум для успеха presale
    uint256 public immutable hardCap;           // максимум сбора
    uint256 public immutable tokenPrice;        // wei per token (18 decimals)
    uint256 public immutable listingPercent;    // % от raised ETH идёт в ликвидность
    uint256 public immutable listingTokenPercent; // % токенов для ликвидности
    uint256 public immutable saleEnd;
    
    uint256 public totalRaised;
    bool public finalized;
    bool public listed;
    address public liquidityPair;
    
    mapping(address => uint256) public contributions;
    
    event Contribution(address indexed contributor, uint256 ethAmount);
    event Finalized(bool success, uint256 totalRaised);
    event ListedOnDEX(address pair, uint256 ethLiquidity, uint256 tokenLiquidity);
    event Refunded(address indexed contributor, uint256 amount);
    
    constructor(
        address _token,
        address _router,
        uint256 _softCap,
        uint256 _hardCap,
        uint256 _tokenPrice,
        uint256 _listingPercent,
        uint256 _listingTokenPercent,
        uint256 _saleEndTimestamp,
        address _owner
    ) Ownable2Step() {
        token = IERC20(_token);
        router = IUniswapV2Router02(_router);
        softCap = _softCap;
        hardCap = _hardCap;
        tokenPrice = _tokenPrice;
        listingPercent = _listingPercent;
        listingTokenPercent = _listingTokenPercent;
        saleEnd = _saleEndTimestamp;
        _transferOwnership(_owner);
    }
    
    // Участие в presale
    receive() external payable {
        _contribute(msg.sender, msg.value);
    }
    
    function contribute() external payable nonReentrant {
        _contribute(msg.sender, msg.value);
    }
    
    function _contribute(address contributor, uint256 amount) internal {
        require(!finalized, "Presale finalized");
        require(block.timestamp < saleEnd, "Sale ended");
        require(totalRaised + amount <= hardCap, "Hard cap reached");
        require(amount > 0, "Zero contribution");
        
        contributions[contributor] += amount;
        totalRaised += amount;
        
        emit Contribution(contributor, amount);
        
        // Автоматический листинг при hardcap
        if (totalRaised >= hardCap) {
            _finalize();
        }
    }
    
    // Финализация после окончания сейла или при hardcap
    function finalize() external {
        require(block.timestamp >= saleEnd || totalRaised >= hardCap, "Too early");
        require(!finalized, "Already finalized");
        _finalize();
    }
    
    function _finalize() internal {
        finalized = true;
        bool success = totalRaised >= softCap;
        
        emit Finalized(success, totalRaised);
        
        if (success) {
            _listOnDEX();
        }
        // Если softCap не достигнут — пользователи получат refund
    }
    
    function _listOnDEX() internal {
        require(!listed, "Already listed");
        listed = true;
        
        // ETH для ликвидности
        uint256 ethForLiquidity = totalRaised * listingPercent / 100;
        
        // Токены для ликвидности
        uint256 totalTokens = token.balanceOf(address(this));
        uint256 tokensForLiquidity = totalTokens * listingTokenPercent / 100;
        
        // Апрувим роутеру
        token.safeApprove(address(router), tokensForLiquidity);
        
        // Добавляем ликвидность — LP токены идут на адрес(0) = burn
        // Это делает ликвидность постоянной и нераздельной
        (uint256 addedToken, uint256 addedETH, uint256 lpTokens) = router.addLiquidityETH{
            value: ethForLiquidity
        }(
            address(token),
            tokensForLiquidity,
            tokensForLiquidity * 95 / 100, // slippage 5%
            ethForLiquidity * 95 / 100,
            address(0xdead),               // LP tokens burned = locked forever
            block.timestamp + 600          // deadline 10 минут
        );
        
        // Получаем адрес пула
        address factory = router.factory();
        liquidityPair = IUniswapV2Factory(factory).getPair(
            address(token),
            0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 // WETH
        );
        
        emit ListedOnDEX(liquidityPair, addedETH, addedToken);
        
        // Оставшийся ETH (за вычетом ликвидности) — в treasury
        uint256 remaining = address(this).balance;
        if (remaining > 0) {
            payable(owner()).transfer(remaining);
        }
    }
    
    // Возврат при неудаче (softCap не достигнут)
    function claimRefund() external nonReentrant {
        require(finalized, "Not finalized");
        require(totalRaised < softCap, "Presale successful, no refund");
        
        uint256 amount = contributions[msg.sender];
        require(amount > 0, "No contribution");
        
        contributions[msg.sender] = 0;
        payable(msg.sender).transfer(amount);
        
        emit Refunded(msg.sender, amount);
    }
    
    // Клейм токенов при успехе
    function claimTokens() external nonReentrant {
        require(finalized && listed, "Not listed yet");
        
        uint256 contribution = contributions[msg.sender];
        require(contribution > 0, "Nothing to claim");
        
        // Сколько токенов получает участник (пропорционально вкладу)
        uint256 participantTokens = token.balanceOf(address(this)) 
            * contribution / totalRaised;
        
        contributions[msg.sender] = 0;
        token.safeTransfer(msg.sender, participantTokens);
    }
}

Расчёт листинговой цены

Листинговая цена на DEX определяется соотношением токенов и ETH в пуле при создании. Это нужно чётко коммуницировать участникам presale:

Presale цена: 0.001 ETH per token
Hardcap: 100 ETH
listingPercent: 70% (70 ETH в ликвидность)
listingTokenPercent: 20% (из presale аллокации)

Допустим, продано 100,000,000 токенов за 100 ETH
Токенов для ликвидности: 20,000,000
ETH для ликвидности: 70 ETH

Листинговая цена: 70 / 20,000,000 = 0.0000035 ETH
Это выше presale цены → участники в прибыли с момента листинга

Если листинговая цена ниже presale цены — участники presale сразу в убытке. Это плохо для репутации проекта. Рассчитывайте параметры заранее.

Uniswap V3 листинг

Uniswap V2 проще для автолистинга (нет ценового диапазона). Uniswap V3 позволяет концентрированную ликвидность, но требует указания price range:

import "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";

function _listOnUniswapV3() internal {
    INonfungiblePositionManager posManager = INonfungiblePositionManager(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
    
    // Создаём пул с начальной ценой
    uint160 sqrtPriceX96 = calculateSqrtPrice(ethForLiquidity, tokensForLiquidity);
    posManager.createAndInitializePoolIfNecessary(
        address(token),
        WETH_ADDRESS,
        3000, // 0.3% fee tier
        sqrtPriceX96
    );
    
    // Минтим позицию с широким диапазоном (почти full range)
    INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
        token0: address(token) < WETH_ADDRESS ? address(token) : WETH_ADDRESS,
        token1: address(token) < WETH_ADDRESS ? WETH_ADDRESS : address(token),
        fee: 3000,
        tickLower: -887220, // почти минимум
        tickUpper: 887220,  // почти максимум
        amount0Desired: ...,
        amount1Desired: ...,
        amount0Min: 0,
        amount1Min: 0,
        recipient: address(0xdead), // burn LP NFT
        deadline: block.timestamp + 600
    });
    
    posManager.mint{value: ethForLiquidity}(params);
}

Для V3 нужен WETH wrap токенов ETH через WETH.deposit{value: amount}(). Сложнее, но позволяет более эффективную ликвидность.

LP Lock альтернативы

Вместо сжигания LP токенов (address(0xdead)) — отправка на Lock контракт с временным замком:

contract LPLocker {
    struct Lock {
        address token;      // LP token address
        uint256 amount;
        uint256 unlockAt;
        address owner;
    }
    
    mapping(uint256 => Lock) public locks;
    uint256 public lockCount;
    
    function lock(address lpToken, uint256 amount, uint256 unlockTimestamp) 
        external returns (uint256 lockId) 
    {
        require(unlockTimestamp > block.timestamp, "Invalid unlock time");
        
        lockId = ++lockCount;
        IERC20(lpToken).safeTransferFrom(msg.sender, address(this), amount);
        
        locks[lockId] = Lock({
            token: lpToken,
            amount: amount,
            unlockAt: unlockTimestamp,
            owner: msg.sender
        });
    }
    
    function unlock(uint256 lockId) external {
        Lock storage lk = locks[lockId];
        require(msg.sender == lk.owner, "Not owner");
        require(block.timestamp >= lk.unlockAt, "Still locked");
        
        IERC20(lk.token).safeTransfer(lk.owner, lk.amount);
        delete locks[lockId];
    }
}

Публичный lock сервис (UNCX, Team.Finance, PinkLock) более удобен с точки зрения доверия — пользователи могут проверить lock в известном интерфейсе.

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

Reentrancy: функции с ETH transfer + token transfer потенциально уязвимы. nonReentrant на все публичные функции обязательно.

Front-running листинга: MEV боты могут front-run транзакцию листинга, купив токены до добавления ликвидности. Если токен торгуется до листинга (маловероятно при правильной архитектуре) — используйте commit-reveal или flashbots bundle.

Slippage в addLiquidityETH: amountTokenMin и amountETHMin не должны быть 0 — иначе сэндвич-атака может добавить непропорциональную ликвидность. 3–5% slippage tolerance достаточно.

Срок разработки: 2–3 недели включая presale контракт, LP locker, тесты на fork. Аудит обязателен — контракт держит средства участников.