@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-12

package/contracts/offchain-helpers/AutomateReady.sol

@@ -3,17 +3,17 @@ pragma solidity ^0.8.14;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-    enum Module {
-        RESOLVER,
-        TIME,
-        PROXY,
-        SINGLE_EXEC
-    }
+enum Module {
+    RESOLVER,
+    TIME,
+    PROXY,
+    SINGLE_EXEC
+}
 
-    struct ModuleData {
-        Module[] modules;
-        bytes[] args;
-    }
+struct ModuleData {
+    Module[] modules;
+    bytes[] args;
+}
 
 interface IAutomate {
     function createTask(
@@ -33,17 +33,9 @@ interface IAutomate {
 }
 
 interface ITaskTreasuryUpgradable {
-    function depositFunds(
-        address receiver,
-        address token,
-        uint256 amount
-    ) external payable;
-
-    function withdrawFunds(
-        address payable receiver,
-        address token,
-        uint256 amount
-    ) external;
+    function depositFunds(address receiver, address token, uint256 amount) external payable;
+
+    function withdrawFunds(address payable receiver, address token, uint256 amount) external;
 }
 
 interface IOpsProxyFactory {
@@ -61,8 +53,7 @@ abstract contract AutomateReady {
     address public immutable dedicatedMsgSender;
     address private immutable _gelato;
     address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
-    address private constant OPS_PROXY_FACTORY =
-    0xC815dB16D4be6ddf2685C201937905aBf338F5D7;
+    address private constant OPS_PROXY_FACTORY = 0xC815dB16D4be6ddf2685C201937905aBf338F5D7;
 
     /**
      * @dev
@@ -81,9 +72,7 @@ abstract contract AutomateReady {
     constructor(address _automate, address _taskCreator) {
         automate = IAutomate(_automate);
         _gelato = IAutomate(_automate).gelato();
-        (dedicatedMsgSender,) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(
-            _taskCreator
-        );
+        (dedicatedMsgSender, ) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(_taskCreator);
     }
 
     /**
@@ -94,18 +83,14 @@ abstract contract AutomateReady {
      */
     function _transfer(uint256 _fee, address _feeToken) internal {
         if (_feeToken == ETH) {
-            (bool success,) = _gelato.call{value: _fee}("");
+            (bool success, ) = _gelato.call{value: _fee}("");
             require(success, "_transfer: ETH transfer failed");
         } else {
             SafeERC20.safeTransfer(IERC20(_feeToken), _gelato, _fee);
         }
     }
 
-    function _getFeeDetails()
-    internal
-    view
-    returns (uint256 fee, address feeToken)
-    {
+    function _getFeeDetails() internal view returns (uint256 fee, address feeToken) {
         (fee, feeToken) = automate.getFeeDetails();
     }
 }

package/contracts/offchain-helpers/BaseSplitCodeFactoryContract.sol

@@ -17,7 +17,10 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeable {
         __BoringOwnable_init();
     }
 
-    function deploy(string memory name, bytes calldata creationCode)
+    function deploy(
+        string memory name,
+        bytes calldata creationCode
+    )
         external
         onlyOwner
         returns (
@@ -27,8 +30,8 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeable {
             uint256 creationCodeSizeB
         )
     {
-        (creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB) =
-            BaseSplitCodeFactory.setCreationCode(creationCode);
+        (creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB) = BaseSplitCodeFactory
+            .setCreationCode(creationCode);
         emit Deployed(name, creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB);
     }
 }

package/contracts/offchain-helpers/BoringLpSeller.sol

@@ -12,13 +12,8 @@ abstract contract BoringLpSeller {
     /// @param netLpIn amount of Lp to sell
     /// @param tokenOut should be included in SY.getTokensOut()
     /// @return netTokenOut amount of token out
-    function _sellLpForToken(
-        address market,
-        uint256 netLpIn,
-        address tokenOut
-    ) internal returns (uint256 netTokenOut) {
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
+    function _sellLpForToken(address market, uint256 netLpIn, address tokenOut) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         IPMarket(market).transfer(market, netLpIn);
 
@@ -29,16 +24,8 @@ abstract contract BoringLpSeller {
             uint256 netSyFromPt = YT.redeemPY(address(SY));
             netSyToRedeem = netSyRemoved + netSyFromPt;
         } else {
-            (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(
-                address(SY),
-                market,
-                netLpIn
-            );
-            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(
-                address(SY),
-                netPtRemoved,
-                EMPTY_BYTES
-            );
+            (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(address(SY), market, netLpIn);
+            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(address(SY), netPtRemoved, EMPTY_BYTES);
             netSyToRedeem = netSyRemoved + netSySwappedOut;
         }
 

package/contracts/offchain-helpers/BoringPtSeller.sol

@@ -12,13 +12,8 @@ abstract contract BoringPtSeller {
     /// @param netPtIn amount of Pt to sell
     /// @param tokenOut should be included in SY.getTokensOut()
     /// @return netTokenOut amount of token out
-    function _sellPtForToken(
-        address market,
-        uint256 netPtIn,
-        address tokenOut
-    ) internal returns (uint256 netTokenOut) {
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
-            .readTokens();
+    function _sellPtForToken(address market, uint256 netPtIn, address tokenOut) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 netSyOut;
         if (PT.isExpired()) {

package/contracts/offchain-helpers/Broadcaster.sol

@@ -28,7 +28,7 @@ contract Broadcaster is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable
         lastBroadcastedWeek = currentWeek;
 
         votingController.finalizeEpoch();
-        for (uint256 i = 0; i < chainIds.length;) {
+        for (uint256 i = 0; i < chainIds.length; ) {
             uint64 chainId = chainIds[i];
             uint256 fee = votingController.getBroadcastResultFee(chainId);
             votingController.broadcastResults{value: fee}(chainId);

package/contracts/offchain-helpers/BytesLib.sol

@@ -57,10 +57,14 @@ library BytesLib {
             // length of the arrays.
             end := add(mc, length)
 
-            for { let cc := add(_postBytes, 0x20) } lt(mc, end) {
+            for {
+                let cc := add(_postBytes, 0x20)
+            } lt(mc, end) {
                 mc := add(mc, 0x20)
                 cc := add(cc, 0x20)
-            } { mstore(mc, mload(cc)) }
+            } {
+                mstore(mc, mload(cc))
+            }
 
             // Update the free-memory pointer by padding our last write location
             // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
@@ -168,7 +172,9 @@ library BytesLib {
                 } lt(mc, end) {
                     sc := add(sc, 1)
                     mc := add(mc, 0x20)
-                } { sstore(sc, mload(mc)) }
+                } {
+                    sstore(sc, mload(mc))
+                }
 
                 mask := exp(0x100, sub(mc, end))
 
@@ -200,7 +206,9 @@ library BytesLib {
                 } lt(mc, end) {
                     sc := add(sc, 1)
                     mc := add(mc, 0x20)
-                } { sstore(sc, mload(mc)) }
+                } {
+                    sstore(sc, mload(mc))
+                }
 
                 mask := exp(0x100, sub(mc, end))
 
@@ -246,7 +254,9 @@ library BytesLib {
                 } lt(mc, end) {
                     mc := add(mc, 0x20)
                     cc := add(cc, 0x20)
-                } { mstore(mc, mload(cc)) }
+                } {
+                    mstore(mc, mload(cc))
+                }
 
                 mstore(tempBytes, _length)
 
@@ -385,10 +395,9 @@ library BytesLib {
                 let mc := add(_preBytes, 0x20)
                 let end := add(mc, length)
 
-                for { let cc := add(_postBytes, 0x20) }
-                // the next line is the loop condition:
-                // while(uint256(mc < end) + cb == 2)
-                eq(add(lt(mc, end), cb), 2) {
+                for {
+                    let cc := add(_postBytes, 0x20)
+                } eq(add(lt(mc, end), cb), 2) { // while(uint256(mc < end) + cb == 2) // the next line is the loop condition:
                     mc := add(mc, 0x20)
                     cc := add(cc, 0x20)
                 } {
@@ -451,10 +460,11 @@ library BytesLib {
                     let numTailBytes := and(length, 0x1f)
                     let mcRem := mload(mc)
                     let ccRem := mload(cc)
-                    for { let i := 0 }
-                    // the next line is the loop condition:
-                    // while(uint256(i < numTailBytes) + cb == 2)
-                    eq(add(lt(i, numTailBytes), cb), 2) { i := add(i, 1) } {
+                    for {
+                        let i := 0
+                    } eq(add(lt(i, numTailBytes), cb), 2) { // while(uint256(i < numTailBytes) + cb == 2) // the next line is the loop condition:
+                        i := add(i, 1)
+                    } {
                         if iszero(eq(byte(i, mcRem), byte(i, ccRem))) {
                             // unsuccess:
                             success := 0
@@ -515,7 +525,9 @@ library BytesLib {
 
                         // the next line is the loop condition:
                         // while(uint256(mc < end) + cb == 2)
-                        for {} eq(add(lt(mc, end), cb), 2) {
+                        for {
+
+                        } eq(add(lt(mc, end), cb), 2) {
                             sc := add(sc, 1)
                             mc := add(mc, 0x20)
                         } {

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.17;
-
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";

package/contracts/offchain-helpers/LegacyNFTHelper.sol

@@ -26,23 +26,14 @@ interface StarNFTV1 {
         uint256[] ids,
         uint256[] values
     );
-    event TransferSingle(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256 id,
-        uint256 value
-    );
+    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
     event URI(string value, uint256 indexed id);
 
     function addMinter(address minter) external;
 
     function balanceOf(address account, uint256 id) external view returns (uint256);
 
-    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
-        external
-        view
-        returns (uint256[] memory);
+    function balanceOfBatch(address[] memory accounts, uint256[] memory ids) external view returns (uint256[] memory);
 
     function baseURI() external view returns (string memory);
 
@@ -56,11 +47,7 @@ interface StarNFTV1 {
 
     function mint(address account, uint256 powah) external returns (uint256);
 
-    function mintBatch(
-        address account,
-        uint256 amount,
-        uint256[] memory powahArr
-    ) external returns (uint256[] memory);
+    function mintBatch(address account, uint256 amount, uint256[] memory powahArr) external returns (uint256[] memory);
 
     function minters(address) external view returns (bool);
 
@@ -78,13 +65,7 @@ interface StarNFTV1 {
         bytes memory data
     ) external;
 
-    function safeTransferFrom(
-        address from,
-        address to,
-        uint256 id,
-        uint256 amount,
-        bytes memory data
-    ) external;
+    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external;
 
     function setApprovalForAll(address operator, bool approved) external;
 

package/contracts/offchain-helpers/LimitBackendHelper.sol

@@ -19,11 +19,11 @@ contract LimitBackendHelper is TokenHelper {
     }
 
     /// @notice vanilla read
-    function readSingleToken(address token, address[] calldata owners, address spender)
-        public
-        view
-        returns (uint256[] memory balances, uint256[] memory allowances)
-    {
+    function readSingleToken(
+        address token,
+        address[] calldata owners,
+        address spender
+    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
         balances = new uint256[](owners.length);
         allowances = new uint256[](owners.length);
         for (uint256 i = 0; i < owners.length; i++) {
@@ -33,11 +33,11 @@ contract LimitBackendHelper is TokenHelper {
     }
 
     /// @notice auto return balances and allowances the input tokens of the orders, based on type
-    function readMultiTokens(address[] calldata tokens, address[] calldata owners, address spender)
-        public
-        view
-        returns (uint256[] memory balances, uint256[] memory allowances)
-    {
+    function readMultiTokens(
+        address[] calldata tokens,
+        address[] calldata owners,
+        address spender
+    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
         require(tokens.length == owners.length, "Length mismatch");
         balances = new uint256[](owners.length);
         allowances = new uint256[](owners.length);
@@ -62,7 +62,11 @@ contract LimitBackendHelper is TokenHelper {
         for (uint256 i = 0; i < length; i++) {
             (, bytes memory result) = original.delegatecall(
                 abi.encodeWithSignature(
-                    "mintSyFromTokenRevert(address,address,address,uint256)", makers[i], SY, tokens[i], amounts[i]
+                    "mintSyFromTokenRevert(address,address,address,uint256)",
+                    makers[i],
+                    SY,
+                    tokens[i],
+                    amounts[i]
                 )
             );
             minted[i] = parseMinted(result);
@@ -82,10 +86,12 @@ contract LimitBackendHelper is TokenHelper {
         }
     }
 
-    function mintSyFromTokenRevert(address maker, address SY, address token, uint256 makingAmount)
-        public
-        returns (uint256)
-    {
+    function mintSyFromTokenRevert(
+        address maker,
+        address SY,
+        address token,
+        uint256 makingAmount
+    ) public returns (uint256) {
         _transferIn(token, maker, makingAmount);
         if (token == WNATIVE && !IStandardizedYield(SY).isValidTokenIn(WNATIVE)) {
             _wrap_unwrap_ETH(WNATIVE, NATIVE, makingAmount);
@@ -93,7 +99,10 @@ contract LimitBackendHelper is TokenHelper {
         }
         _safeApproveInf(token, SY);
         uint256 minted = IStandardizedYield(SY).deposit{value: token == NATIVE ? makingAmount : 0}(
-            address(this), token, makingAmount, 0
+            address(this),
+            token,
+            makingAmount,
+            0
         );
         revert Errors.SimulationResults(true, abi.encode(minted));
     }

package/contracts/offchain-helpers/MarketExchangeRateLib.sol

@@ -11,21 +11,10 @@ library MarketExchangeRateLib {
 
     function getMarketExchangeRate(address market) internal view returns (uint256) {
         MarketState memory state = IPMarket(market).readState(address(0));
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            _getPYIndexCurrent(market),
-            block.timestamp
-        );
+        MarketPreCompute memory comp = state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
 
         return
-            MarketMathCore
-                ._getExchangeRate(
-                    state.totalPt,
-                    comp.totalAsset,
-                    comp.rateScalar,
-                    comp.rateAnchor,
-                    0
-                )
-                .Uint();
+            MarketMathCore._getExchangeRate(state.totalPt, comp.totalAsset, comp.rateScalar, comp.rateAnchor, 0).Uint();
     }
 
     function _getPYIndexCurrent(address market) private view returns (PYIndex) {

package/contracts/offchain-helpers/Multicall2.sol

@@ -16,9 +16,7 @@ contract Multicall2 {
         bytes returnData;
     }
 
-    function aggregate(
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes[] memory returnData) {
+    function aggregate(Call[] memory calls) public returns (uint256 blockNumber, bytes[] memory returnData) {
         blockNumber = block.number;
         returnData = new bytes[](calls.length);
         for (uint256 i = 0; i < calls.length; i++) {
@@ -66,10 +64,7 @@ contract Multicall2 {
         blockHash = blockhash(block.number - 1);
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        Call[] memory calls
-    ) public returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, Call[] memory calls) public returns (Result[] memory returnData) {
         returnData = new Result[](calls.length);
         for (uint256 i = 0; i < calls.length; i++) {
             (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -15,7 +15,7 @@ contract PendleMulticallV1 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -31,15 +31,15 @@ contract PendleMulticallV1 {
         }
     }
 
-    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (Result[] memory returnData)
-    {
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV2.sol

@@ -17,7 +17,7 @@ contract PendleMulticallV2 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -33,15 +33,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (Result[] memory returnData)
-    {
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
@@ -59,15 +59,14 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregateRevert(uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (bytes[] memory returnData)
-    {
+    function tryAggregateRevert(
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (bytes[] memory returnData) {
         uint256 length = calls.length;
         returnData = new bytes[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (, returnData[i]) = address(this).delegatecall{gas: gasLimit}(

package/contracts/offchain-helpers/PendleOffchainStorage.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../interfaces/IPOffchainStorage.sol";
+
+contract PendleOffchainStorage is IPOffchainStorage, UUPSUpgradeable, AccessControlUpgradeable {
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    constructor() initializer {}
+
+    modifier onlyMaintainer() {
+        require(isMaintainer(msg.sender), "not maintainer");
+        _;
+    }
+
+    function isMaintainer(address addr) public view returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                CORE
+    //////////////////////////////////////////////////////////////*/
+
+    mapping(bytes32 => bytes) internal _storage;
+
+    function setStorageUint256(bytes32 key, uint256 value) external onlyMaintainer {
+        _setStorage(key, abi.encode(value));
+    }
+
+    function setStorage(bytes32 key, bytes memory value) external onlyMaintainer {
+        _setStorage(key, value);
+    }
+
+    function getUint256(bytes32 key) external view returns (uint256) {
+        return abi.decode(_storage[key], (uint256));
+    }
+
+    function _setStorage(bytes32 key, bytes memory value) internal {
+        _storage[key] = value;
+        emit SetStorage(key, value);
+    }
+
+    // TODO: update more getSomething functions later when theres a need
+
+    /*///////////////////////////////////////////////////////////////
+                            UPGRADABLE RELATED
+    //////////////////////////////////////////////////////////////*/
+    function initialize() external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not admin");
+    }
+
+    uint256[49] private __gap;
+}

package/contracts/offchain-helpers/SimulateHelper.sol

@@ -10,18 +10,17 @@ contract SimulateHelper {
         original = address(this);
     }
 
-    function multicallRevert(uint256 gasLimit, address[] calldata targets, bytes[] calldata callDatas)
-        public
-        payable
-        virtual
-        returns (bytes[] memory res, uint256[] memory gasUsed)
-    {
+    function multicallRevert(
+        uint256 gasLimit,
+        address[] calldata targets,
+        bytes[] calldata callDatas
+    ) public payable virtual returns (bytes[] memory res, uint256[] memory gasUsed) {
         require(targets.length == callDatas.length, "length mismatch");
 
         uint256 length = callDatas.length;
         res = new bytes[](length);
         gasUsed = new uint256[](length);
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             uint256 gasBefore = gasleft();
             (, res[i]) = original.delegatecall{gas: gasLimit}(
                 abi.encodeWithSignature("simulate(address,bytes)", targets[i], callDatas[i])

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -1,10 +1,24 @@
 pragma solidity ^0.8.0;
 
 library SDKErrorsDirectory {
+    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 BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
     error ApproxBinarySearchInputInvalid(
-        uint256 approxGuessMin, uint256 approxGuessMax, uint256 minGuessMin, uint256 maxGuessMax
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
     );
     error MarketExpired();
     error MarketZeroAmountsInput();