פיתוח AMM DEX על Uniswap V2/V3 עם ביקורת

כשקיבלנו על עצמנו את פרויקט ה-AMM DEX הראשון עבור לקוח DeFi, חישוב שגוי של השפעת מחיר הוביל להפסד של 50,000 דולר תוך שעה. מאז, אנחנו בודקים כל נוסחה פעמיים ומסתמכים רק על תבניות מוכחות בשטח. בניית AMM DEX היא לא רק כתיבת חוזה חכם—זו מערכת מורכבת: מתמטיקת תמחור, הגנת MEV, כלכלת מאגרי נזילות ו-UX. במאמר זה, אנחנו מפרקים כיצד לבנות DEX מאפס: מנוסחת המוצר הקבוע ועד לפריסה ברשת המרכזית. כבר סיפקנו DEX ליותר מ-10 פרויקטים, עם שווי כולל נעול העולה על 50 מיליון דולר. הניסיון שלנו משתרע על פני Ethereum, Arbitrum, Polygon ו-BNB Chain. אם אתם מתכננים השקת DEX משלכם, תצטרכו יותר מקוד—אתם צריכים מומחיות ביצירת שוק ואבטחה. כאן אנחנו חולקים פתרונות מעשיים.

למה נוסחת המוצר הקבוע עדיין רלוונטית

AMM (Automated Market Maker) מחליף את ספר ההזמנות המסורתי בנוסחה מתמטית. Uniswap V2 הפך לפופולרי את x * y = k—המכפלה של הרזרבות נשארת קבועה. המחיר של טוקן X ביחידות של Y הוא price = y / x. במהלך החלפה, הסוחר מוסיף Δx ומקבל Δy, תוך התחשבות בעמלה של 0.3%. השפעת מחיר—שינוי המחיר—פרופורציונלית ישירות לגודל העסקה ביחס למאגר. זה יסודי: הזמנות גדולות מקבלות תמחור גרוע במאגרים קטנים.

הנוסחה עם עמלה: Δy = y * Δx * (1 - fee) / (x + Δx * (1 - fee)). למרות פשטותה, היא לא יעילה עבור נכסים עם אותו מחיר (מטבעות יציבים). כאן נכנסת הנוסחה ההיברידית של Curve.

איך נזילות מרוכזת משנה את יעילות ההון

Uniswap V3 הציג נזילות מרוכזת: ספקי נזילות (LPs) מגדירים טווח מחירים [Pa, Pb]. מחוץ לטווח זה, הנזילות לא פעילה. נוסחאות: x = L * (1/√P - 1/√Pb), y = L * (√P - √Pa). יעילות ההון עולה פי 100-4000 עבור זוגות מטבעות יציבים, אבל ספקי הנזילות מתמודדים עם הפסד בלתי קבוע מורכב יותר.

ארכיטקטורת חוזה חכם ל-AMM DEX

ארכיטקטורה טיפוסית מורכבת מחוזי Factory, Pair (Pool) ו-Router. ה-Factory יוצר מאגרים באמצעות CREATE2:

contract AmmFactory {
    mapping(address => mapping(address => address)) public getPair;

    function createPair(address tokenA, address tokenB) external returns (address pair) {
        require(tokenA != tokenB, "IDENTICAL_ADDRESSES");
        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
        require(token0 != address(0), "ZERO_ADDRESS");
        require(getPair[token0][token1] == address(0), "PAIR_EXISTS");
        bytes memory bytecode = type(AmmPair).creationCode;
        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
        assembly {
            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        IAmmPair(pair).initialize(token0, token1);
        getPair[token0][token1] = pair;
        getPair[token1][token0] = pair;
    }
}

חוזה ה-Pair הוא הליבה: הוא מאחסן רזרבות, מנפיק טוקני LP, מבצע החלפות עם העברה אופטימית ובדיקת אינווריאנטים. תבנית ההלוואה המהירה (flash loan) מוטמעת דרך קריאה חוזרת (callback):

function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
    if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
    if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
    uint balance0 = IERC20(_token0).balanceOf(address(this));
    uint balance1 = IERC20(_token1).balanceOf(address(this));
    uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
    uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
    require(amount0In > 0 || amount1In > 0, "INSUFFICIENT_INPUT_AMOUNT");
    uint balance0Adjusted = balance0 * 1000 - amount0In * 3;
    uint balance1Adjusted = balance1 * 1000 - amount1In * 3;
    require(balance0Adjusted * balance1Adjusted >= uint(_reserve0) * _reserve1 * 1000**2, "K");
    _update(balance0, balance1, _reserve0, _reserve1);
}

חוזה ה-Router מספק מסלולים מרובי-קפיצות, הגנת החלקה (slippage) ומועד אחרון.

הגנת MEV ו-Reentrancy

התקפת סנדוויץ' קלאסית: בוט MEV מכניס קנייה לפני ההחלפה של הקורבן ומכירה אחריה. הגנה: סובלנות להחלקה—המשתמש מגדיר השפעת מחיר מקסימלית; mempool פרטי (Flashbots); סכמות commit-reveal; מכירות פומביות בקבוצות (CoW Protocol)—כל ההזמנות מבוצעות במחיר אחד.

הגנת Reentrancy: ה-mutex contract AmmFactory { mapping(address => mapping(address => address)) public getPair; function createPair(address tokenA, address tokenB) external returns (address pair) { require(tokenA != tokenB, "IDENTICAL_ADDRESSES"); (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); require(token0 != address(0), "ZERO_ADDRESS"); require(getPair[token0][token1] == address(0), "PAIR_EXISTS"); bytes memory bytecode = type(AmmPair).creationCode; bytes32 salt = keccak256(abi.encodePacked(token0, token1)); assembly { pair := create2(0, add(bytecode, 32), mload(bytecode), salt) } IAmmPair(pair).initialize(token0, token1); getPair[token0][token1] = pair; getPair[token1][token0] = pair; } } משתמש בחריץ אחסון אחד, חוסך כ-2300 גז בהשוואה ל-ReentrancyGuard של OpenZeppelin.

uint private unlocked = 1;
modifier lock() {
    require(unlocked == 1, "LOCKED");
    unlocked = 0;
    _;
    unlocked = 1;
}

טוקנומיקה וממשל

אנחנו ממליצים על מבנה עמלות דו-שכבתי: עמלת LP (0.3%) + עמלת פרוטוקול (0.05%), גם אם עמלת הפרוטוקול כבויה בתחילה. טוקני ממשל מופצים דרך כריית נזילות באמצעות תבנית MasterChef (SushiSwap). נוסחה מפושטת: function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock { (uint112 _reserve0, uint112 _reserve1,) = getReserves(); if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data); uint balance0 = IERC20(_token0).balanceOf(address(this)); uint balance1 = IERC20(_token1).balanceOf(address(this)); uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0; uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0; require(amount0In > 0 || amount1In > 0, "INSUFFICIENT_INPUT_AMOUNT"); uint balance0Adjusted = balance0 * 1000 - amount0In * 3; uint balance1Adjusted = balance1 * 1000 - amount1In * 3; require(balance0Adjusted * balance1Adjusted >= uint(_reserve0) * _reserve1 * 1000**2, "K"); _update(balance0, balance1, _reserve0, _reserve1); } .

חזית (Frontend) ו-UX

רכיבים קריטיים: ממשק החלפה עם השפעת מחיר בזמן אמת, ניהול נזילות עם ויזואליזציה של טווחים (עבור V3), גרפים דרך The Graph, אינטגרציית ארנק (wagmi + viem, WalletConnect v2), סימולציית עסקאות דרך Tenderly.

איך לפרוס AMM DEX ב-5 שלבים

1. פיתוח חוזים חכמים (Factory, Pair, Router) עם בדיקות Foundry.
2. ביקורת אבטחה (Slither, Mythril, Echidna) ואימות פורמלי.
3. פריסה לרשת בדיקות (testnet), אינטגרציה עם החזית.
4. בדיקת מאגרי נזילות עם טוקנים אמיתיים.
5. פריסה לרשת המרכזית, הגדרת ניטור (Tenderly, Etherscan API).

מה כלול בפיתוח AMM DEX

למה להזמין פיתוח מאיתנו?

אנחנו מבטיחים איכות קוד ומוכנות לביקורת. רקורד שלנו—מעל 10 פרויקטי DEX מוצלחים, כולל אינטגרציות Layer 2 (Arbitrum, Optimism). אנחנו משתמשים בתבניות וספריות מוכחות. המסמך הלבן של Uniswap V2 הוא הבסיס שאנחנו מתאימים לצרכים שלכם. Automated Market Maker הוא המנגנון המרכזי בליבה. צרו קשר לייעוץ חינם והערכת פרויקט. הזמינו פיתוח AMM DEX סוהר—מרעיון ועד פריסה ותמיכה.