@pendle/core-v2 0.16.2-testnet → 0.16.3-testnet

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -0,0 +1,250 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../../interfaces/IPBulkSeller.sol";
+
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/Math.sol";
+import "../libraries/Errors.sol";
+
+import "./BulkSellerMathCore.sol";
+
+contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuardUpgradeable {
+    using Math for uint256;
+    using SafeERC20 for IERC20;
+    using BulkSellerMathCore for BulkSellerState;
+
+    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
+    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
+    event RateUpdated(
+        uint256 newRateTokenToSy,
+        uint256 newRateSyToToken,
+        uint256 oldRateTokenToSy,
+        uint256 oldRateSyToToken
+    );
+    event ReBalanceTokenToSy(
+        uint256 netTokenDeposit,
+        uint256 netSyFromToken,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReBalanceSyToToken(
+        uint256 netSyRedeem,
+        uint256 netTokenFromSy,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
+    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
+
+    struct BulkSellerStorage {
+        uint128 rateTokenToSy;
+        uint128 rateSyToToken;
+        uint128 totalSy;
+        uint128 totalToken;
+    }
+
+    address public token;
+    address public SY;
+    uint64 public feeRate;
+
+    address public factory;
+    BulkSellerStorage public _storage;
+
+    modifier onlyMaintainer() {
+        if (!IPBulkSellerFactory(factory).isMaintainer(msg.sender))
+            revert Errors.BulkNotMaintainer();
+        _;
+    }
+
+    modifier onlyAdmin() {
+        if (!IPBulkSellerFactory(factory).isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
+        _;
+    }
+
+    // Since this contract is a beacon contract, no constructor should be defined.
+    function initialize(
+        address _token,
+        address _SY,
+        address _factory
+    ) external initializer {
+        __ReentrancyGuard_init();
+        token = _token;
+        SY = _SY;
+        factory = _factory;
+    }
+
+    function swapExactTokenForSy(
+        address receiver,
+        uint256 netTokenIn,
+        uint256 minSyOut
+    ) external nonReentrant returns (uint256 netSyOut) {
+        BulkSellerState memory state = readState();
+
+        netSyOut = state.swapExactTokenForSy(netTokenIn);
+
+        if (netSyOut < minSyOut) revert Errors.BulkInSufficientSyOut(netSyOut, minSyOut);
+
+        if (receiver != address(this)) _transferOut(SY, receiver, netSyOut);
+
+        _writeState(state);
+
+        if (_selfBalance(token) < state.totalToken)
+            revert Errors.BulkInsufficientTokenReceived(_selfBalance(token), state.totalToken);
+
+        emit SwapExactTokenForSy(receiver, netTokenIn, netSyOut);
+    }
+
+    function swapExactSyForToken(
+        address receiver,
+        uint256 exactSyIn,
+        uint256 minTokenOut
+    ) external nonReentrant returns (uint256 netTokenOut) {
+        BulkSellerState memory state = readState();
+
+        netTokenOut = state.swapExactSyForToken(exactSyIn);
+
+        if (netTokenOut < minTokenOut)
+            revert Errors.BulkInSufficientTokenOut(netTokenOut, minTokenOut);
+        if (receiver != address(this)) _transferOut(token, receiver, netTokenOut);
+
+        _writeState(state);
+
+        if (_selfBalance(SY) < state.totalSy)
+            revert Errors.BulkInsufficientSyReceived(_selfBalance(SY), state.totalSy);
+
+        emit SwapExactSyForToken(receiver, exactSyIn, netTokenOut);
+    }
+
+    function calcSwapExactTokenForSy(uint256 netTokenIn) external view returns (uint256 netSyOut) {
+        assert(_storage.rateTokenToSy != 0);
+        netSyOut = netTokenIn.mulDown(_storage.rateTokenToSy);
+    }
+
+    function calcSwapExactSyForToken(uint256 netSyIn) external view returns (uint256 netTokenOut) {
+        assert(_storage.rateSyToToken != 0);
+        netTokenOut = netSyIn.mulDown(_storage.rateSyToToken);
+    }
+
+    function readState() public view returns (BulkSellerState memory state) {
+        BulkSellerStorage storage s = _storage;
+
+        state = BulkSellerState({
+            rateTokenToSy: s.rateTokenToSy,
+            rateSyToToken: s.rateSyToToken,
+            totalToken: s.totalToken,
+            totalSy: s.totalSy,
+            feeRate: feeRate
+        });
+    }
+
+    function _writeState(BulkSellerState memory state) internal {
+        BulkSellerStorage memory tmp = BulkSellerStorage({
+            rateTokenToSy: state.rateTokenToSy.Uint128(),
+            rateSyToToken: state.rateSyToToken.Uint128(),
+            totalSy: state.totalSy.Uint128(),
+            totalToken: state.totalToken.Uint128()
+        });
+
+        _storage = tmp;
+    }
+
+    // ----------------- BulkSeller management -----------------
+
+    function increaseReserve(uint256 netTokenIn, uint256 netSyIn) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        state.totalToken += netTokenIn;
+        state.totalSy += netSyIn;
+
+        _transferIn(token, msg.sender, netTokenIn);
+        _transferIn(SY, msg.sender, netSyIn);
+
+        emit ReserveUpdated(state.totalToken, state.totalSy);
+
+        _writeState(state);
+    }
+
+    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyAdmin {
+        BulkSellerState memory state = readState();
+
+        if (netTokenOut == type(uint256).max) netTokenOut = state.totalToken;
+        if (netSyOut == type(uint256).max) netSyOut = state.totalSy;
+
+        state.totalToken -= netTokenOut;
+        state.totalSy -= netSyOut;
+
+        _transferOut(token, msg.sender, netTokenOut);
+        _transferOut(SY, msg.sender, netSyOut);
+
+        emit ReserveUpdated(state.totalToken, state.totalSy);
+
+        _writeState(state);
+    }
+
+    function reBalance(uint256 targetProp, uint256 maxDiff) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+        uint256 oldTokenProp = state.getTokenProp();
+
+        (uint256 netTokenDeposit, uint256 netSyRedeem) = state.getReBalanceParams(targetProp);
+
+        if (netTokenDeposit > 0) {
+            uint256 netSyFromToken = _depositToken(netTokenDeposit);
+            state.reBalanceTokenToSy(netTokenDeposit, netSyFromToken, maxDiff);
+
+            uint256 newTokenProp = state.getTokenProp();
+            emit ReBalanceTokenToSy(netTokenDeposit, netSyFromToken, newTokenProp, oldTokenProp);
+        } else {
+            uint256 netTokenFromSy = _redeemSy(netSyRedeem);
+            state.reBalanceSyToToken(netSyRedeem, netTokenFromSy, maxDiff);
+
+            uint256 newTokenProp = state.getTokenProp();
+            emit ReBalanceSyToToken(netSyRedeem, netTokenFromSy, newTokenProp, oldTokenProp);
+        }
+
+        _writeState(state);
+    }
+
+    function setRate(
+        uint256 newRateSyToToken,
+        uint256 newRateTokenToSy,
+        uint256 maxDiff
+    ) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        emit RateUpdated(
+            newRateTokenToSy,
+            newRateSyToToken,
+            state.rateTokenToSy,
+            state.rateSyToToken
+        );
+
+        state.setRate(newRateSyToToken, newRateTokenToSy, maxDiff);
+
+        _writeState(state);
+    }
+
+    function setFeeRate(uint64 newFeeRate) external onlyMaintainer {
+        emit FeeRateUpdated(newFeeRate, feeRate);
+        feeRate = newFeeRate;
+    }
+
+    function getTokenProp() external view returns (uint256) {
+        BulkSellerState memory state = readState();
+        return state.getTokenProp();
+    }
+
+    function _depositToken(uint256 netTokenDeposit) internal returns (uint256 netSyFromToken) {
+        _safeApprove(token, SY, netTokenDeposit);
+        return IStandardizedYield(SY).deposit(address(this), token, netTokenDeposit, 0);
+    }
+
+    function _redeemSy(uint256 netSyRedeem) internal returns (uint256 netTokenFromSy) {
+        _transferOut(SY, SY, netSyRedeem);
+        return IStandardizedYield(SY).redeem(address(this), netSyRedeem, token, 0, true);
+    }
+}

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/proxy/beacon/IBeacon.sol";
+import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
+import "@openzeppelin/contracts/access/AccessControl.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/Errors.sol";
+
+contract BulkSellerFactory is
+    IBeacon,
+    IPBulkSellerFactory,
+    AccessControl,
+    UUPSUpgradeable,
+    Initializable
+{
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    address public implementation;
+
+    mapping(address => mapping(address => address)) internal syToBulkSeller;
+
+    modifier onlyAdmin() {
+        if (!isAdmin(msg.sender)) revert Errors.BulkNotAdmin();
+        _;
+    }
+
+    constructor() initializer {}
+
+    function initialize(address implementation_) external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        upgradeBeacon(implementation_);
+    }
+
+    function createBulkSeller(address token, address SY)
+        external
+        onlyAdmin
+        returns (address bulk)
+    {
+        IStandardizedYield _SY = IStandardizedYield(SY);
+        if (syToBulkSeller[token][SY] != address(0))
+            revert Errors.BulkSellerAlreadyExisted(token, SY, syToBulkSeller[token][SY]);
+        if (_SY.isValidTokenIn(token) == false || _SY.isValidTokenOut(token) == false)
+            revert Errors.BulkSellerInvalidToken(token, SY);
+
+        bytes memory data = abi.encodeWithSignature(
+            "initialize(address,address,address)",
+            token,
+            SY,
+            address(this)
+        );
+
+        bulk = address(new BeaconProxy(address(this), data));
+
+        syToBulkSeller[token][SY] = bulk;
+
+        return bulk;
+    }
+
+    function get(address token, address SY) external view override returns (address) {
+        if (syToBulkSeller[token][SY] == address(0))
+            revert Errors.RouterBulkSellerNotFound(token, SY);
+        return syToBulkSeller[token][SY];
+    }
+
+    function isMaintainer(address addr) public view override returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    function isAdmin(address addr) public view override returns (bool) {
+        return hasRole(DEFAULT_ADMIN_ROLE, addr);
+    }
+
+    // ----------------- upgrade-related -----------------
+    function upgradeBeacon(address newImplementation) public onlyAdmin {
+        require(
+            Address.isContract(newImplementation),
+            "UpgradeableBeacon: implementation is not a contract"
+        );
+        implementation = newImplementation;
+        emit UpgradedBeacon(newImplementation);
+    }
+
+    function _authorizeUpgrade(address) internal override onlyAdmin {}
+}

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/Math.sol";
+import "../libraries/Errors.sol";
+
+struct BulkSellerState {
+    uint256 rateTokenToSy;
+    uint256 rateSyToToken;
+    uint256 totalToken;
+    uint256 totalSy;
+    uint256 feeRate;
+}
+
+library BulkSellerMathCore {
+    using Math for uint256;
+
+    function swapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
+        internal
+        pure
+        returns (uint256 netSyOut)
+    {
+        netSyOut = calcSwapExactTokenForSy(state, netTokenIn);
+        state.totalToken += netTokenIn;
+        state.totalSy -= netSyOut;
+    }
+
+    function swapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
+        internal
+        pure
+        returns (uint256 netTokenOut)
+    {
+        netTokenOut = calcSwapExactSyForToken(state, netSyIn);
+        state.totalSy += netSyIn;
+        state.totalToken -= netTokenOut;
+    }
+
+    function calcSwapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
+        internal
+        pure
+        returns (uint256 netSyOut)
+    {
+        uint256 postFeeRate = state.rateTokenToSy.mulDown(Math.ONE - state.feeRate);
+        assert(postFeeRate != 0);
+
+        netSyOut = netTokenIn.mulDown(postFeeRate);
+        if (netSyOut > state.totalSy)
+            revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
+    }
+
+    function calcSwapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
+        internal
+        pure
+        returns (uint256 netTokenOut)
+    {
+        uint256 postFeeRate = state.rateSyToToken.mulDown(Math.ONE - state.feeRate);
+        assert(postFeeRate != 0);
+
+        netTokenOut = netSyIn.mulDown(postFeeRate);
+        if (netTokenOut > state.totalToken)
+            revert Errors.BulkInsufficientTokenForTrade(state.totalToken, netTokenOut);
+    }
+
+    function getTokenProp(BulkSellerState memory state) internal pure returns (uint256) {
+        uint256 totalToken = state.totalToken;
+        uint256 totalTokenFromSy = state.totalSy.mulDown(state.rateSyToToken);
+        return totalToken.divDown(totalToken + totalTokenFromSy);
+    }
+
+    function getReBalanceParams(BulkSellerState memory state, uint256 targetTokenProp)
+        internal
+        pure
+        returns (uint256 netTokenToDeposit, uint256 netSyToRedeem)
+    {
+        uint256 currentTokenProp = getTokenProp(state);
+
+        if (currentTokenProp > targetTokenProp) {
+            netTokenToDeposit = state.totalToken.mulDown(
+                (currentTokenProp - targetTokenProp).divDown(currentTokenProp)
+            );
+        } else {
+            uint256 currentSyProp = Math.ONE - currentTokenProp;
+            netSyToRedeem = state.totalSy.mulDown(
+                (targetTokenProp - currentTokenProp).divDown(currentSyProp)
+            );
+        }
+    }
+
+    function reBalanceTokenToSy(
+        BulkSellerState memory state,
+        uint256 netTokenToDeposit,
+        uint256 netSyFromToken,
+        uint256 maxDiff
+    ) internal pure {
+        uint256 rate = netSyFromToken.divDown(netTokenToDeposit);
+
+        if (!Math.isAApproxB(rate, state.rateTokenToSy, maxDiff))
+            revert Errors.BulkBadRateTokenToSy(rate, state.rateTokenToSy, maxDiff);
+
+        state.totalToken -= netTokenToDeposit;
+        state.totalSy += netSyFromToken;
+    }
+
+    function reBalanceSyToToken(
+        BulkSellerState memory state,
+        uint256 netSyToRedeem,
+        uint256 netTokenFromSy,
+        uint256 maxDiff
+    ) internal pure {
+        uint256 rate = netTokenFromSy.divDown(netSyToRedeem);
+
+        if (!Math.isAApproxB(rate, state.rateSyToToken, maxDiff))
+            revert Errors.BulkBadRateSyToToken(rate, state.rateSyToToken, maxDiff);
+
+        state.totalToken += netTokenFromSy;
+        state.totalSy -= netSyToRedeem;
+    }
+
+    function setRate(
+        BulkSellerState memory state,
+        uint256 rateTokenToSy,
+        uint256 rateSyToToken,
+        uint256 maxDiff
+    ) internal pure {
+        if (
+            state.rateTokenToSy != 0 &&
+            !Math.isAApproxB(rateTokenToSy, state.rateTokenToSy, maxDiff)
+        ) {
+            revert Errors.BulkBadRateTokenToSy(rateTokenToSy, state.rateTokenToSy, maxDiff);
+        }
+
+        if (
+            state.rateSyToToken != 0 &&
+            !Math.isAApproxB(rateSyToToken, state.rateSyToToken, maxDiff)
+        ) {
+            revert Errors.BulkBadRateSyToToken(rateSyToToken, state.rateSyToToken, maxDiff);
+        }
+
+        state.rateTokenToSy = rateTokenToSy;
+        state.rateSyToToken = rateSyToToken;
+    }
+}

package/contracts/core/StandardizedYield/implementations/Convex/ConvexCurveLP/PendleConvexLPSY.sol

@@ -143,12 +143,10 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         override
         returns (uint256 amountTokenOut)
     {
-        uint256 amountLpTokenToReceive = (amountSharesToRedeem * exchangeRate()) / 1e18;
-
         if (tokenOut == crvLp) {
-            amountTokenOut = amountLpTokenToReceive;
+            amountTokenOut = amountSharesToRedeem;
         } else {
-            amountTokenOut = _previewRedeemFromCurve(tokenOut, amountLpTokenToReceive);
+            amountTokenOut = _previewRedeemFromCurve(tokenOut, amountSharesToRedeem);
         }
     }
 

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../libraries/math/Math.sol";
+import "../../../../../interfaces/Curve/ICrvPool.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+library CurveFraxUsdcPoolHelper {
+    uint256 public constant N_COINS = 2;
+    uint256 public constant A_PRECISION = 100;
+    uint256 public constant PRECISION = 10 ** 18;
+    uint256 public constant RATE_0 = 1000000000000000000;
+    uint256 public constant RATE_1 = 1000000000000000000000000000000;
+    uint256 public constant FEE_DENOMINATOR = 10 ** 10;
+
+    using Math for uint256;
+
+    function previewAddLiquidity(address pool, uint256[N_COINS] memory _amounts) internal view returns (uint256) {
+        uint256 amp = ICrvPool(pool).A_precise();
+        uint256[N_COINS] memory old_balances;
+        old_balances[0] = ICrvPool(pool).balances(0);
+        old_balances[1] = ICrvPool(pool).balances(1);
+        uint256 D0 = _get_D_mem(old_balances, amp);
+        
+        address lp_token = ICrvPool(pool).lp_token();
+        uint256 total_supply = IERC20(lp_token).totalSupply();
+
+        uint256[N_COINS] memory new_balances;
+        new_balances[0] = old_balances[0];
+        new_balances[1] = old_balances[1];
+
+        for(uint256 i = 0; i < N_COINS; ++i) {
+            // skip totalSupply = 0 check
+            new_balances[i] += _amounts[i];
+        }
+
+        uint256 D1 = _get_D_mem(new_balances, amp);
+        assert (D1 > D0);
+
+        uint256[N_COINS] memory fees;
+
+        // skip total_supply > 0 check
+        uint256 fee = ICrvPool(pool).fee() * N_COINS / (4 * (N_COINS - 1));
+        for (uint256 i = 0; i < N_COINS; ++i) {
+            uint256 ideal_balance = D1 * old_balances[i] / D0;
+            uint256 difference = 0;
+            uint256 new_balance = new_balances[i];
+
+            if (ideal_balance > new_balance) {
+                difference = ideal_balance - new_balance;
+            } else {
+                difference = new_balance - ideal_balance;
+            }
+            fees[i] = fee * difference / FEE_DENOMINATOR;
+            new_balances[i] -= fees[i];
+        }
+        uint256 D2 = _get_D_mem(new_balances, amp);
+        return total_supply * (D2 - D0) / D0;
+    }
+
+    function _get_D_mem(uint256[N_COINS] memory balances, uint256 _amp)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256[N_COINS] memory _xp;
+        _xp[0] = RATE_0 * balances[0] / PRECISION;
+        _xp[1] = RATE_1 * balances[1] / PRECISION;
+
+        return _get_D(_xp, _amp);
+    }
+
+    function _get_D(uint256[N_COINS] memory _xp, uint256 _amp) internal pure returns (uint256) {
+        uint256 S = 0;
+        uint256 Dprev = 0;
+
+        for (uint256 k = 0; k < N_COINS; ++k) {
+            S += _xp[k];
+        }
+        if (S == 0) return 0;
+
+        uint256 D = S;
+        uint256 Ann = _amp * N_COINS;
+
+        for (uint256 _i = 0; _i < 255; ++_i) {
+            uint256 D_P = D;
+            for (uint256 k = 0; k < N_COINS; ++k) {
+                D_P = (D_P * D) / (_xp[k] * N_COINS);
+            }
+            Dprev = D;
+            D =
+                (((Ann * S) / A_PRECISION + D_P * N_COINS) * D) /
+                (((Ann - A_PRECISION) * D) / A_PRECISION + (N_COINS + 1) * D_P);
+
+            if (D > Dprev) {
+                if (D - Dprev <= 1) {
+                    return D;
+                }
+            } else {
+                if (Dprev - D <= 1) {
+                    return D;
+                }
+            }
+        }
+        assert(false);
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.sol

@@ -50,9 +50,10 @@ contract PendleWstEthSY is SYBase {
             } else {
                 if (tokenIn == wETH) IWETH(wETH).withdraw(amountDeposited);
 
-                uint256 preBalanceStEth = _selfBalance(stETH);
-                IStETH(stETH).submit{ value: amountDeposited }(address(0));
-                amountStETH = _selfBalance(stETH) - preBalanceStEth;
+                uint256 amountStEthSharesOut = IStETH(stETH).submit{ value: amountDeposited }(
+                    address(0)
+                );
+                amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
             }
             amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
         }
@@ -101,7 +102,21 @@ contract PendleWstEthSY is SYBase {
     {
         if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
         else {
-            amountSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
+            if (tokenIn != stETH) {
+                uint256 totalShares = IStETH(stETH).getTotalShares();
+                uint256 totalPooledEth = IStETH(stETH).getTotalPooledEther();
+                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(
+                    amountTokenToDeposit
+                );
+
+                totalShares += amountStEthSharesOut;
+                totalPooledEth += amountTokenToDeposit;
+
+                uint256 stEthBalance = (amountStEthSharesOut * totalPooledEth) / totalShares;
+                amountSharesOut = (stEthBalance * totalShares) / totalPooledEth;
+            } else {
+                amountSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
+            }
         }
     }
 

package/contracts/core/libraries/Errors.sol

@@ -4,6 +4,20 @@ pragma solidity 0.8.17;
 /// Adapted from UniswapV3's Oracle
 
 library Errors {
+    // BulkSeller
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientTokenReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulkSeller);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
+
     // APPROX
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
@@ -46,12 +60,15 @@ library Errors {
     error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
     error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
     error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
+    error RouterBulkSellerNotFound(address token, address SY);
     error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
 
     error RouterTimeRangeZero();
     error RouterCallbackNotPendleMarket(address caller);
     error RouterInvalidAction(bytes4 selector);
 
+    error RouterKyberSwapDataZero();
+
     // YIELD CONTRACT
     error YCExpired();
     error YCNotExpired();