@pendle/core-v2 3.0.0-beta-10 → 3.0.0

package/contracts/limit/Mock.sol

@@ -0,0 +1,429 @@
+// import "../pendle/contracts/limit/PendleLimitRouter.sol";
+import "./PendleLimitRouter.sol";
+import "hardhat/console.sol";
+
+contract PendleLimitRouterMock is PendleLimitRouter {
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
+    using PMath for uint256;
+    using PMath for int256;
+
+    uint256 public constant MAKE_SY = 1e18;
+    uint256 public constant MAKE_PT = 1e18;
+    uint256 public constant MAKE_YT = 1e18;
+    uint256 public constant R = 1021525557649751706;
+    uint256 public constant INDEX = 1034898125855333936;
+    uint256 public constant FEE_RATE = 1000524863070060643;
+    uint256 public constant IMPLIED_RATE = 40566962068769599;
+
+    constructor(address _WNATIVE) PendleLimitRouter(_WNATIVE) {}
+
+    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes memory callback)
+        external
+        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
+    {
+        _validateOrdersSkipSig(params);
+        OrderType orderType = params[0].order.orderType;
+        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
+            return flashFillTokenForPY(Args(orderType, params, receiver, maxInput, callback));
+        } else {
+            return flashFillPYForToken(Args(orderType, params, receiver, maxInput, callback));
+        }
+    }
+
+    function flashFillTokenForPY(Args memory a)
+        internal
+        returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee)
+    {
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndRemaining(a.params);
+
+        // Token => This
+        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
+
+        NormalResults memory out;
+        (totalSyFromTaker, totalPYToTaker, totalFee, out) = calcFlashBatch(a.params, YT, lnFeeRateRoot);
+
+        require(totalSyFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
+
+        // Taker => This
+        _transferFrom(IERC20(SY), msg.sender, address(this), totalSyFromTaker);
+
+        // This => YT
+        _transferOut(SY, YT, totalSyFromTaker + out.totalMaking - out.totalFee);
+
+        bool isPtToMaker = (a.orderType == OrderType.SY_FOR_PT);
+        address pyToMaker = isPtToMaker ? PT : YT;
+        {
+            address receiverPt = isPtToMaker ? address(this) : a.receiver;
+            address receiverYt = isPtToMaker ? a.receiver : address(this);
+
+            // PT => receiverPt, YT => receiverYt
+            IPYieldToken(YT).mintPY(receiverPt, receiverYt);
+        }
+
+        // This => Makers
+        _transferToMakers(IERC20(pyToMaker), address(this), a.params, out.netTakings);
+
+        // This => Fee
+        _transferOut(SY, feeRecipient, totalFee);
+
+        // toMakers == netTakings
+        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
+    }
+
+    function flashFillPYForToken(Args memory a)
+        internal
+        returns (uint256 totalSyToTaker, uint256 totalPYFromTaker, uint256 totalFee)
+    {
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndRemaining(a.params);
+
+        NormalResults memory out;
+        (totalPYFromTaker, totalSyToTaker, totalFee, out) = calcFlashBatch(a.params, YT, lnFeeRateRoot);
+
+        require(totalPYFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
+
+        bool ptFromTaker = (a.orderType == OrderType.YT_FOR_SY);
+        address pyFromTaker = ptFromTaker ? PT : YT;
+        address pyFromMaker = ptFromTaker ? YT : PT;
+
+        // Taker => YT
+        _transferFrom(IERC20(pyFromTaker), msg.sender, YT, totalPYFromTaker);
+        // Maker => YT
+        _transferFromMakers(IERC20(pyFromMaker), a.params, YT, out.netMakings);
+
+        // YT => This
+        IPYieldToken(YT).redeemPY(address(this));
+
+        // This => Taker
+        _transferOut(SY, a.receiver, totalSyToTaker);
+
+        // This => Makers
+        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
+
+        // This => Fee
+        _transferOut(SY, feeRecipient, totalFee);
+
+        // fromMakers == netMakings
+        _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
+    }
+
+    function calcFlashBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
+        internal
+        returns (
+            uint256 netInputFromTaker,
+            uint256 netOutputToTaker,
+            uint256 netFee,
+            IPOrderMixinType.NormalResults memory out
+        )
+    {
+        function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash =
+            getCalcFunctions2(params[0].order.orderType);
+
+        uint256 timeToExpiry = IPYieldToken(YT).expiry() - block.timestamp;
+        uint256 pyIndex = IPYieldToken(YT).pyIndexCurrent();
+
+        out = LimitMath.calcNormalBatch(params, timeToExpiry, pyIndex, lnFeeRateRoot);
+        (netInputFromTaker, netOutputToTaker) =
+            calcFlash(out.totalMaking, out.totalTaking, out.totalFee, PYIndex.wrap(pyIndex));
+        netFee = out.totalFee;
+    }
+
+    // Proof of index.syToAsset(index.assetToSyUp(takePt)) >= takePt at end of this file
+    function calcSyForPtFlash(uint256 makeSy, uint256 takePt, uint256 fee, PYIndex index)
+        internal
+        pure
+        returns (uint256 syFromTaker, uint256 ytToTaker)
+    {
+        uint256 syToMintPy = index.assetToSyUp(takePt);
+
+        syFromTaker = syToMintPy - (makeSy - fee);
+        ytToTaker = takePt;
+    }
+
+    function calcPtForSyFlash(uint256 makePt, uint256 takeSy, uint256 fee, PYIndex index)
+        internal
+        pure
+        returns (uint256 ytFromTaker, uint256 syToTaker)
+    {
+        uint256 syRedeemFromPy = index.assetToSy(makePt);
+        syToTaker = syRedeemFromPy - (takeSy + fee);
+
+        ytFromTaker = makePt;
+    }
+
+    function calcSyForYtFlash(uint256 makeSy, uint256 takeYt, uint256 fee, PYIndex index)
+        internal
+        pure
+        returns (uint256 syFromTaker, uint256 ptToTaker)
+    {
+        uint256 syToMintPy = index.assetToSyUp(takeYt);
+
+        syFromTaker = syToMintPy - (makeSy - fee);
+        ptToTaker = takeYt;
+    }
+
+    function calcYtForSyFlash(uint256 makeYt, uint256 takeSy, uint256 fee, PYIndex index)
+        internal
+        pure
+        returns (uint256 ptFromTaker, uint256 syToTaker)
+    {
+        uint256 syRedeemFromPy = index.assetToSy(makeYt);
+
+        syToTaker = syRedeemFromPy - (takeSy + fee);
+        ptFromTaker = makeYt;
+    }
+
+    /// @dev diff sig for calcNormal and calcFlash to avoid miscalling
+    function getCalcFunctions2(IPOrderMixinType.OrderType t)
+        internal
+        pure
+        returns (function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash)
+    {
+        if (t == IPOrderMixinType.OrderType.SY_FOR_PT) {
+            return calcSyForPtFlash;
+        } else if (t == IPOrderMixinType.OrderType.PT_FOR_SY) {
+            return calcPtForSyFlash;
+        } else if (t == IPOrderMixinType.OrderType.SY_FOR_YT) {
+            return calcSyForYtFlash;
+        } else {
+            return calcYtForSyFlash;
+        }
+    }
+
+    function runAllTests(address YT) public {
+        testCalcSyForPtNormal();
+        testCalcPtForSyNormal();
+        testCalcSyForYtNormal();
+        testCalcYtForSyNormal();
+        testCalcSyForPtFlash();
+        testCalcPtForSyFlash();
+        testCalcSyForYtFlash();
+        testCalcYtForSyFlash();
+    }
+
+    function normalFillTokenForPYStatic(FillOrderParams[] memory params)
+        public
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
+    {
+        address YT = params[0].order.YT;
+        _updMaking(params);
+        _mintSyStatic(params);
+        NormalResults memory out = LimitMath.calcNormalBatch(params, YT, lnFeeRateRoot);
+        (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
+    }
+
+    function normalFillPYForTokenStatic(FillOrderParams[] memory params)
+        public
+        returns (
+            uint256 actualMaking,
+            uint256 actualTaking,
+            uint256 totalFee,
+            uint256 actualTokenOut,
+            uint256[] memory tokensOut
+        )
+    {
+        address YT = params[0].order.YT;
+        _updMaking(params);
+        NormalResults memory out = LimitMath.calcNormalBatch(params, YT, lnFeeRateRoot);
+        (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
+
+        tokensOut = _redeemSyStatic(params, out.netTakings);
+
+        for (uint256 i = 0; i < params.length; i = _inc1(i)) {
+            actualTokenOut += tokensOut[i];
+        }
+    }
+
+    function flashFillTokenForPYStatic(FillOrderParams[] memory params)
+        public
+        returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee)
+    {
+        address YT = params[0].order.YT;
+        _updMaking(params);
+        _mintSyStatic(params);
+        NormalResults memory out;
+        (totalSyFromTaker, totalPYToTaker, totalFee, out) = calcFlashBatch(params, YT, lnFeeRateRoot);
+    }
+
+    function flashFillPYForTokenStatic(FillOrderParams[] memory params)
+        public
+        returns (
+            uint256 totalSyToTaker,
+            uint256 totalPYFromTaker,
+            uint256 totalFee,
+            uint256 actualTokenOut,
+            uint256[] memory tokensOut
+        )
+    {
+        address YT = params[0].order.YT;
+        _updMaking(params);
+        NormalResults memory out;
+        (totalPYFromTaker, totalSyToTaker, totalFee, out) = calcFlashBatch(params, YT, lnFeeRateRoot);
+
+        tokensOut = _redeemSyStatic(params, out.netTakings);
+        for (uint256 i = 0; i < params.length; i = _inc1(i)) {
+            actualTokenOut += tokensOut[i];
+        }
+    }
+
+    function _updMaking(FillOrderParams[] memory params) internal {
+        uint256 len = params.length;
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            FillOrderParams memory param = params[i];
+
+            uint256 remainingMakerAmount = _status[hashOrder(param.order)].remaining;
+            if (remainingMakerAmount == 0) remainingMakerAmount = param.order.makingAmount;
+            else remainingMakerAmount--;
+
+            uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
+
+            param.makingAmount = netMaking;
+        }
+    }
+
+    function _mintSyStatic(FillOrderParams[] memory params) internal {
+        address YT = params[0].order.YT;
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 len = params.length;
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            params[i].makingAmount =
+                IStandardizedYield(SY).previewDeposit(params[i].order.token, params[i].makingAmount);
+        }
+    }
+
+    function _redeemSyStatic(FillOrderParams[] memory params, uint256[] memory netSyOuts)
+        internal
+        returns (uint256[] memory tokensOut)
+    {
+        uint256 len = params.length;
+        tokensOut = new uint256[](len);
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            FillOrderParams memory param = params[i];
+            uint256 netSyOut = netSyOuts[i];
+
+            if (netSyOut == 0) continue;
+
+            tokensOut[i] =
+                IStandardizedYield(IPYieldToken(param.order.YT).SY()).previewRedeem(param.order.token, netSyOut);
+        }
+    }
+
+    function transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
+        public
+        payable
+        returns (uint256[] memory newMakings)
+    {
+        newMakings = new uint256[](params.length);
+        _transferFromMakers_mintSy_updMakings(SY, params);
+
+        for (uint256 i = 0; i < params.length; i = _inc1(i)) {
+            newMakings[i] = params[i].makingAmount;
+        }
+    }
+
+    function redeemSy_transferToMakers(address SY, FillOrderParams[] memory params, uint256[] memory netSyOuts)
+        public
+        returns (uint256[] memory toMakers)
+    {
+        return _redeemSy_transferToMakers(SY, params, netSyOuts);
+    }
+
+    function testCalcSyForPtNormal() public returns (uint256 takePt, uint256 fee) {
+        console.log("testCalcSyForPtNormal");
+        (takePt, fee,) = LimitMath.calcSyForPtNormal(MAKE_SY, R, PYIndex.wrap(INDEX), FEE_RATE);
+        console.log("takePt: %s, fee: %s", takePt, fee);
+        require(takePt == 1057174885125052923 && fee == 524863070060643);
+
+        // trade 1 SY (1.0349 asset) -> 1.0572 PT, fee of 0.00052486 SY (0.00054318 asset) 0.052% fee
+    }
+
+    function testCalcPtForSyNormal() public returns (uint256 takeSy, uint256 fee) {
+        console.log("testCalcPtForSyNormal");
+        (takeSy, fee,) = LimitMath.calcPtForSyNormal(MAKE_PT, R, PYIndex.wrap(INDEX), FEE_RATE);
+        console.log("takeSy: %s, fee: %s", takeSy, fee);
+        require(takeSy == 945917287735898378 && fee == 496216605893315);
+
+        // trade 1 PT -> 0.94592 SY (0.97893 asset), fee of 0.00049622 SY (0.00051353 asset) 0.052459% fee
+    }
+
+    function testCalcSyForYtNormal() public returns (uint256 takeYt, uint256 fee) {
+        console.log("testCalcSyForYtNormal");
+        (takeYt, fee,) = LimitMath.calcSyForYtNormal(MAKE_SY, R, PYIndex.wrap(INDEX), FEE_RATE);
+        console.log("takeYt: %s, fee: %s", takeYt, fee);
+        require(takeYt == 49112543439135815980 && fee == 24370459612155973);
+
+        // trade 1 SY (1.0349 asset) -> 49.11254 YT, fee of 0.02437 SY (0.025221 asset) 2.437% fee
+        // PT / YT ratio = 46.45
+    }
+
+    function testCalcYtForSyNormal() public returns (uint256 takeSy, uint256 fee) {
+        console.log("testCalcYtForSyNormal");
+        (takeSy, fee,) = LimitMath.calcYtForSyNormal(MAKE_YT, R, PYIndex.wrap(INDEX), FEE_RATE);
+        console.log("takeSy: %s, fee: %s", takeSy, fee);
+        require(takeSy == 20361397109055853 && fee == 496477051664500);
+
+        // trade 1 YT -> 0.02036 SY (0.02107 asset), fee of 0.0004964770517 SY (0.0005138031711 asset) 2.438% fee
+        // PT / YT ratio = 46.45
+    }
+
+    function testCalcSyForPtFlash() public {
+        console.log("testCalcSyForPtFlash");
+
+        (uint256 takePt, uint256 fee) = testCalcSyForPtNormal();
+        (uint256 syFromTaker, uint256 ytToTaker) = calcSyForPtFlash(MAKE_SY, takePt, fee, PYIndex.wrap(INDEX));
+
+        console.log("syFromTaker: %s, ytToTaker: %s", syFromTaker, ytToTaker);
+        require(syFromTaker == 22050420719812349 && ytToTaker == 1057174885125052923);
+
+        // trade 1 SY (1.0349 asset) -> 1.0572 PT, fee of 0.00052486 SY (0.00054318 asset) 0.052% fee
+        // flash fill 0.02205 SY (0.02281 asset) to 1.0572 YT 2.38% fee
+
+        // rough formula syFromTaker = makeSy * (r-1) + makeSy * (f-1)
+    }
+
+    function testCalcPtForSyFlash() public {
+        console.log("testCalcPtForSyFlash");
+
+        (uint256 takeSy, uint256 fee) = testCalcPtForSyNormal();
+        (uint256 ytFromTaker, uint256 syToTaker) = calcPtForSyFlash(MAKE_PT, takeSy, fee, PYIndex.wrap(INDEX));
+
+        console.log("ytFromTaker: %s, syToTaker: %s", ytFromTaker, syToTaker);
+        require(ytFromTaker == 1e18 && syToTaker == 19865180503162537);
+        // trade 1 PT -> 0.94592 SY (0.97893 asset), fee of 0.00049622 SY (0.00051353 asset) 0.052459% fee
+        // flash fill 1 YT to 0.019865 SY (0.020558 asset) 2.498% fee
+
+        // rough formula syToTaker = takeSy * (r-1) - takeSy * (f-1)/f)
+    }
+
+    function testCalcSyForYtFlash() public {
+        console.log("testCalcSyForYtFlash");
+
+        (uint256 takeYt, uint256 fee) = testCalcSyForYtNormal();
+        (uint256 syFromTaker, uint256 ptToTaker) = calcSyForYtFlash(MAKE_SY, takeYt, fee, PYIndex.wrap(INDEX));
+
+        console.log("syFromTaker: %s, ptToTaker: %s", syFromTaker, ptToTaker);
+        require(syFromTaker == 46480774343370997703 && ptToTaker == 49112543439135815980);
+        // trade 1 SY (1.0349 asset) -> 49.11254 YT, fee of 0.02437 SY (0.025221 asset) 2.437% fee
+        // flash fill 46.48077 SY (48.07977 asset) to 49.11254 PT 0.052% fee
+
+        // rough formula syFromTaker = (makeSy + makeSy * (f-1)/f) / (r-1)
+    }
+
+    function testCalcYtForSyFlash() public {
+        console.log("testCalcYtForSyFlash");
+
+        (uint256 takeSy, uint256 fee) = testCalcYtForSyNormal();
+        (uint256 ptFromTaker, uint256 syToTaker) = calcYtForSyFlash(MAKE_YT, takeSy, fee, PYIndex.wrap(INDEX));
+
+        console.log("ptFromTaker: %s, syToTaker: %s", ptFromTaker, syToTaker);
+        require(ptFromTaker == 1e18 && syToTaker == 945420810684233877);
+        // trade 1 YT -> 0.02036 SY (0.02107 asset), fee of 0.0004968 SY (0.0005138 asset) 2.438% fee
+        // flash fill 1 PT to 0.94542 SY 0.0525% fee
+
+        // rough formula syToTaker = (takeSy - takeSy * (f-1)) / (r-1)
+    }
+}

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/BulkSellerOffchain.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../core/BulkSeller/BulkSellerMathCore.sol";
+import "../core/BulkSeller/BulkSeller.sol";
+
+contract BulkSellerOffchain {
+    using BulkSellerMathCore for BulkSellerState;
+    using PMath for uint256;
+
+    function calcCurrentRates(IPBulkSeller bulk) external view returns (uint256 rateTokenToSy, uint256 rateSyToToken) {
+        BulkSellerState memory state = bulk.readState();
+        address SY = bulk.SY();
+        address token = bulk.token();
+
+        {
+            uint256 hypoTotalToken = state.totalToken + state.totalSy.mulDown(state.rateSyToToken);
+            uint256 netSyFromToken = IStandardizedYield(SY).previewDeposit(token, hypoTotalToken);
+
+            rateTokenToSy = netSyFromToken.divDown(hypoTotalToken);
+        }
+
+        {
+            uint256 hypoTotalSy = state.totalSy + state.totalToken.mulDown(state.rateTokenToSy);
+            uint256 netTokenFromSy = IStandardizedYield(SY).previewRedeem(token, hypoTotalSy);
+            rateSyToToken = netTokenFromSy.divDown(hypoTotalSy);
+        }
+    }
+
+    function getCurrentState(
+        IPBulkSeller bulk
+    ) external view returns (BulkSellerState memory state, uint256 tokenProp, uint256 hypoTokenBal) {
+        state = bulk.readState();
+
+        tokenProp = state.getTokenProp();
+        hypoTokenBal = state.totalToken + IStandardizedYield(bulk.SY()).previewRedeem(bulk.token(), state.totalSy);
+    }
+
+    function calcCurrentRatesWithAmount(
+        IPBulkSeller bulk,
+        uint256 hypoTotalToken,
+        uint256 hypoTotalSy
+    ) external view returns (uint256 rateTokenToSy, uint256 rateSyToToken) {
+        address SY = bulk.SY();
+        address token = bulk.token();
+
+        {
+            uint256 netSyFromToken = IStandardizedYield(SY).previewDeposit(token, hypoTotalToken);
+            rateTokenToSy = netSyFromToken.divDown(hypoTotalToken);
+        }
+
+        {
+            uint256 netTokenFromSy = IStandardizedYield(SY).previewRedeem(token, hypoTotalSy);
+            rateSyToToken = netTokenFromSy.divDown(hypoTotalSy);
+        }
+    }
+}

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";