פיתוח Rebase Token: אופטימיזציית גז, ביקורת, תאימות DeFi

// Упрощённая реализация
uint256 private constant TOTAL_GONS = type(uint256).max / 2; // большое число
uint256 private _totalSupply;
uint256 private _gonsPerFragment;
mapping(address => uint256) private _gonBalances;

constructor(uint256 initialSupply) {
    _totalSupply = initialSupply;
    _gonsPerFragment = TOTAL_GONS / initialSupply;
    _gonBalances[msg.sender] = TOTAL_GONS;
}

function balanceOf(address account) public view returns (uint256) {
    return _gonBalances[account] / _gonsPerFragment;
}

function rebase(int256 supplyDelta) external onlyOracle returns (uint256) {
    if (supplyDelta == 0) return _totalSupply;
    if (supplyDelta < 0) {
        _totalSupply -= uint256(-supplyDelta);
    } else {
        _totalSupply += uint256(supplyDelta);
    }
    if (_totalSupply > MAX_SUPPLY) _totalSupply = MAX_SUPPLY;
    _gonsPerFragment = TOTAL_GONS / _totalSupply;
    emit LogRebase(epoch, _totalSupply);
    return _totalSupply;
}

function transfer(address to, uint256 value) public override returns (bool) {
    uint256 gonValue = value * _gonsPerFragment;
    _gonBalances[msg.sender] -= gonValue;
    _gonBalances[to] += gonValue;
    emit Transfer(msg.sender, to, value);
    return true;
}

החשבונאות מבוססת המניות ממפה מניות למספר קבוע גדול TOTAL_GONS = type(uint256).max / 2. בעת rebase, רק המחלק משתנה, כך שכל היתרות מתעדכנות ב-O(1).

סוגי טוקני Rebase

היצע אלסטי עם יעד מחיר (בסגנון Ampleforth)

ה-oracle מדווח על המחיר הנוכחי, והחוזה מתאים את ההיצע כדי לקרב את שווי השוק ליעד. כדי לחשב את הדלתא, נעשה שימוש בגורם שיכוך (REBASE_LAG) כדי למנוע חריגה.

function calculateSupplyDelta(uint256 currentPrice, uint256 targetPrice) internal view returns (int256) {
    int256 priceDeviation = int256(currentPrice) - int256(targetPrice);
    int256 deviationPercent = (priceDeviation * 1e18) / int256(targetPrice);
    int256 supplyDelta = (int256(_totalSupply) * deviationPercent) / int256(REBASE_LAG * 1e18);
    return supplyDelta;
}

נושא תשואה (בסגנון stETH)

היתרה גדלה באופן יחסי לתגמולי הסטייקינג. ה-stETH של Lido משתמש במנגנון דומה מבוסס מניות, שבו // Упрощённая реализация uint256 private constant TOTAL_GONS = type(uint256).max / 2; // большое число uint256 private _totalSupply; uint256 private _gonsPerFragment; mapping(address => uint256) private _gonBalances; constructor(uint256 initialSupply) { _totalSupply = initialSupply; _gonsPerFragment = TOTAL_GONS / initialSupply; _gonBalances[msg.sender] = TOTAL_GONS; } function balanceOf(address account) public view returns (uint256) { return _gonBalances[account] / _gonsPerFragment; } function rebase(int256 supplyDelta) external onlyOracle returns (uint256) { if (supplyDelta == 0) return _totalSupply; if (supplyDelta < 0) { _totalSupply -= uint256(-supplyDelta); } else { _totalSupply += uint256(supplyDelta); } if (_totalSupply > MAX_SUPPLY) _totalSupply = MAX_SUPPLY; _gonsPerFragment = TOTAL_GONS / _totalSupply; emit LogRebase(epoch, _totalSupply); return _totalSupply; } function transfer(address to, uint256 value) public override returns (bool) { uint256 gonValue = value * _gonsPerFragment; _gonBalances[msg.sender] -= gonValue; _gonBalances[to] += gonValue; emit Transfer(msg.sender, to, value); return true; } גדל ככל שהאתר הכולל במאגר גדל.

function rebase(uint256 totalPooledEther) external { // totalShares не меняется, но totalPooledEther растёт // => sharesToEth ratio растёт => все балансы растут
    emit TokenRebased(prevTotalShares, _totalShares, prevTotalPooledEther, totalPooledEther, sharesMintedAsFees);
    _totalPooledEther = totalPooledEther;
}

function getPooledEthByShares(uint256 sharesAmount) public view returns (uint256) {
    return sharesAmount * _getTotalPooledEther() / _getTotalShares();
}

למה טוקני Rebase שוברים את ה-DeFi?

זו נקודת הכאב המרכזית שצריך לפתור לפני ההשקה. AMMים (Uniswap, Curve) מאחסנים עתודות מוחלטות — לאחר rebase, היתרה האמיתית במאגר משתנה, אך העתודות לא. פרוטוקולי הלוואות (Aave) עלולים לחסל עמדה במפתיע על rebase שלילי. חלק מהחוזים מחשבים את הסכום שהתקבל דרך function calculateSupplyDelta(uint256 currentPrice, uint256 targetPrice) internal view returns (int256) { int256 priceDeviation = int256(currentPrice) - int256(targetPrice); int256 deviationPercent = (priceDeviation * 1e18) / int256(targetPrice); int256 supplyDelta = (int256(_totalSupply) * deviationPercent) / int256(REBASE_LAG * 1e18); return supplyDelta; } לפני ואחרי העברה, מה שנותן תוצאות שגויות.

אנו מבטיחים תאימות באמצעות גרסה עטופה. לדוגמה, wstETH מאחסן מניות ואינו משנה את היתרה, בעוד ששער ההמרה הוא פונקציה נפרדת. דפוס זה עובד עבור כל נכס מסוג rebasing. בפרויקטים שלנו, זמינות התאימות היא 99.9% לאחר אינטגרציה.

// Wrapped non-rebasing версия
contract WrappedRebaseToken is ERC20 {
    IRebaseToken public immutable underlying;

    function wrap(uint256 amount) external returns (uint256) {
        underlying.transferFrom(msg.sender, address(this), amount);
        uint256 sharesAmount = underlying.getSharesByPooledTokens(amount);
        _mint(msg.sender, sharesAmount);
        return sharesAmount;
    }

    function unwrap(uint256 sharesAmount) external returns (uint256) {
        _burn(msg.sender, sharesAmount);
        uint256 amount = underlying.getPooledTokensByShares(sharesAmount);
        underlying.transfer(msg.sender, amount);
        return amount;
    }
}

איך להגן על טוקן Rebase מפני מניפולציית Oracle?

אם ה-oracle נפרץ, תוקף עלול לאפס את ההיצע או לנפח אותו למקסימום. לכן, אנו תמיד מיישמים:

• TWAP (חלון מינימלי של 30 דקות) במקום מחיר נקודתי
• בדיקת גבולות — שינוי היצע מקסימלי לכל rebase (±10%)
• צבירה מרובת מקורות — Chainlink + TWAP עצמי; סטייה של יותר מ-2% חוסמת את ה-rebase

function rebase() external {
    uint256 chainlinkPrice = getChainlinkPrice();
    uint256 twapPrice = getTWAPPrice();
    require(absDiff(chainlinkPrice, twapPrice) * 100 / chainlinkPrice < 2, "Oracle mismatch");
    int256 supplyDelta = calculateSupplyDelta(twapPrice);
    int256 maxDelta = int256(_totalSupply / 10);
    supplyDelta = clamp(supplyDelta, -maxDelta, maxDelta);
    _rebase(supplyDelta);
}