@pendle/core-v2 5.8.3-factory → 5.8.3

package/contracts/offchain-helpers/SwapNSeed.sol

@@ -1,221 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.17;
-
-import "../interfaces/IPMarket.sol";
-import "../router/math/MarketApproxLibOnchain.sol";
-import "../router/base/ActionBase.sol";
-import "../interfaces/IPMarketSwapNSeed.sol";
-
-contract MarketSwapNSeed is ActionBase, IPMarketSwapNSeed {
-    using PMath for uint256;
-    using PMath for int256;
-    using PYIndexLib for PYIndex;
-    using MarketMathCore for MarketState;
-    using PYIndexLib for IPYieldToken;
-
-    address public immutable router;
-
-    uint256 public constant MAX_ITERATIONS = 30;
-
-    struct MarketTokens {
-        IStandardizedYield SY;
-        IPPrincipalToken PT;
-        IPYieldToken YT;
-    }
-
-    constructor(address _router) {
-        router = _router;
-    }
-
-    function swapNSeed(
-        address receiver,
-        address market,
-        uint256 minLpOut,
-        uint256 minYtOut,
-        TokenInput calldata input,
-        SwapNSeedData calldata snsData
-    ) external payable returns (int256 amountPYToAccount, uint256 netLpOut, uint256 netYtOut) {
-        MarketTokens memory tokens;
-        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
-
-        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
-        amountPYToAccount = _swapBeforeSeeding(receiver, market, tokens, snsData);
-        (netLpOut, netYtOut, ) = _addLiquiditySingleSyKeepYt(
-            receiver,
-            market,
-            tokens.SY,
-            tokens.YT,
-            _selfBalance(tokens.SY),
-            minLpOut,
-            minYtOut
-        );
-    }
-
-    function _addLiquiditySingleSyKeepYt(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 netSyIn,
-        uint256 minLpOut,
-        uint256 minYtOut
-    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
-        MarketState memory state = _readMarket(market);
-
-        PYIndex pyIndex = YT.newIndex();
-
-        netSyMintPy =
-            (netSyIn * state.totalPt.Uint()) /
-            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
-
-        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
-
-        // transfer SY to mint PY
-        _transferOut(address(SY), address(YT), netSyMintPy);
-
-        // the rest of SY goes to market
-        _transferOut(address(SY), market, netSyAddLiquidity);
-
-        // PT goes to market, YT goes to receiver
-        netYtOut = YT.mintPY(market, receiver);
-
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
-
-        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
-        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
-    }
-
-    function _swapBeforeSeeding(
-        address receiver,
-        address market,
-        MarketTokens memory tokens,
-        SwapNSeedData memory snsData
-    ) internal returns (int256 amountPYToAccount) {
-        PYIndex index = _getPYIndex(market);
-        MarketState memory state = _readMarket(market);
-        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
-
-        if (state.lastLnImpliedRate > snsData.targetLnImpliedRate) {
-            // Normalize maxPtToSwap
-            snsData.maxPtToSwap = PMath.min(
-                snsData.maxPtToSwap,
-                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
-            );
-
-            (int256 amountPtToBuy, int256 amountSyToAccount) = _calcAmountPtToBuy(state, comp, index, snsData);
-            amountPYToAccount = amountPtToBuy;
-
-            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
-            IPMarket(market).swapSyForExactPt(receiver, amountPtToBuy.abs(), EMPTY_BYTES);
-        } else {
-            // Normalize maxPtToSwap
-            snsData.maxPtToSwap = PMath.min(
-                snsData.maxPtToSwap,
-                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
-            );
-
-            amountPYToAccount = _calcAmountPtToSell(state, comp, index, snsData);
-            uint256 amountPtToSell = amountPYToAccount.abs();
-            uint256 netPyOut = _mintPyFromSy(
-                address(this),
-                address(tokens.SY),
-                address(tokens.YT),
-                index.assetToSyUp(amountPtToSell),
-                amountPtToSell,
-                false
-            );
-
-            _transferOut(address(tokens.PT), market, netPyOut);
-            _transferOut(address(tokens.YT), receiver, netPyOut);
-
-            // this amount of SY will be used to add liquidity in later step
-            IPMarket(market).swapExactPtForSy(address(this), amountPtToSell, EMPTY_BYTES);
-        }
-    }
-
-    function _calcAmountPtToBuy(
-        MarketState memory state,
-        MarketPreCompute memory comp,
-        PYIndex index,
-        SwapNSeedData memory snsData
-    ) internal pure returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
-        int256 refAmt = snsData.maxPtToSwap.Int();
-        int256 accPtToAccount = 0;
-
-        int256 lastGoodAmountSyToAccount = 0;
-        uint256 lastGoodRate = state.lastLnImpliedRate;
-
-        for (uint256 iter = 0; iter < MAX_ITERATIONS; ++iter) {
-            refAmt /= 2;
-            MarketState memory localState = _deepCopy(state);
-            int256 curPtToAccount = accPtToAccount + refAmt;
-
-            // Will not revert. maxPtToBuy should already be normalized
-            (int256 localAmountSyToAccount, , ) = localState.calcTrade(comp, index, curPtToAccount);
-
-            if (localState.lastLnImpliedRate > snsData.targetLnImpliedRate) {
-                accPtToAccount += refAmt;
-                lastGoodRate = localState.lastLnImpliedRate;
-                lastGoodAmountSyToAccount = localAmountSyToAccount;
-            }
-        }
-
-        if (PMath.isAApproxB(snsData.targetLnImpliedRate, lastGoodRate, snsData.eps)) {
-            amountPtToSwapToAccount = accPtToAccount;
-            amountSyToAccount = lastGoodAmountSyToAccount;
-        } else {
-            revert("_calcAmountPtToBuy: failed");
-        }
-    }
-
-    function _calcAmountPtToSell(
-        MarketState memory state,
-        MarketPreCompute memory comp,
-        PYIndex index,
-        SwapNSeedData memory snsData
-    ) internal pure returns (int256 amountPtToSwapToAccount) {
-        int256 refAmt = snsData.maxPtToSwap.Int();
-        int256 accPtToAccount = 0;
-        uint256 lastGoodRate = state.lastLnImpliedRate;
-
-        for (uint256 iter = 0; iter < MAX_ITERATIONS; ++iter) {
-            refAmt /= 2;
-            MarketState memory localState = _deepCopy(state);
-            int256 curPtToAccount = accPtToAccount - refAmt;
-
-            // Will not revert. maxPtToSell should already be normalized
-            localState.calcTrade(comp, index, curPtToAccount);
-
-            if (localState.lastLnImpliedRate < snsData.targetLnImpliedRate) {
-                accPtToAccount -= refAmt;
-                lastGoodRate = localState.lastLnImpliedRate;
-            }
-        }
-
-        if (PMath.isAApproxB(snsData.targetLnImpliedRate, lastGoodRate, snsData.eps)) {
-            amountPtToSwapToAccount = accPtToAccount;
-        } else {
-            revert("_calcAmountPtToSell: failed");
-        }
-    }
-
-    function _getPYIndex(address market) internal returns (PYIndex) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        return PYIndex.wrap(YT.pyIndexCurrent());
-    }
-
-    function _deepCopy(MarketState memory state) internal pure returns (MarketState memory copiedState) {
-        copiedState.totalPt = state.totalPt;
-        copiedState.totalSy = state.totalSy;
-        copiedState.totalLp = state.totalLp;
-        copiedState.treasury = state.treasury;
-
-        copiedState.scalarRoot = state.scalarRoot;
-        copiedState.expiry = state.expiry;
-
-        copiedState.lnFeeRateRoot = state.lnFeeRateRoot;
-        copiedState.reserveFeePercent = state.reserveFeePercent;
-        copiedState.lastLnImpliedRate = state.lastLnImpliedRate;
-    }
-}

package/contracts/router/swap-aggregator/OneInchScaleHelper.sol

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-
-interface I1inchCommonType {
-    type Address256 is uint256;
-}
-
-abstract contract OneInchScaleHelper is I1inchCommonType {
-    function _rescaleMinAmount(
-        uint256 minAmount,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (uint256) {
-        return (minAmount * newAmount) / oldAmount;
-    }
-
-    function _oneInchScaling(bytes calldata rawCallData, uint256 actualAmount) internal pure returns (bytes memory) {
-        bytes4 selector = bytes4(rawCallData[:4]);
-        bytes memory args = rawCallData[4:];
-
-        if (selector == I1inchAggregationRouterV6.unoswapTo.selector) {
-            (Address256 to, Address256 token, uint256 amount, uint256 minReturn, Address256 dex) = abi.decode(
-                args,
-                (Address256, Address256, uint256, uint256, Address256)
-            );
-
-            minReturn = (minReturn * actualAmount) / amount;
-            amount = actualAmount;
-            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex);
-        }
-
-        if (selector == I1inchAggregationRouterV6.unoswapTo2.selector) {
-            (Address256 to, Address256 token, uint256 amount, uint256 minReturn, Address256 dex, Address256 dex2) = abi
-                .decode(args, (Address256, Address256, uint256, uint256, Address256, Address256));
-
-            minReturn = (minReturn * actualAmount) / amount;
-            amount = actualAmount;
-
-            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex, dex2);
-        }
-
-        if (selector == I1inchAggregationRouterV6.unoswapTo3.selector) {
-            (
-                Address256 to,
-                Address256 token,
-                uint256 amount,
-                uint256 minReturn,
-                Address256 dex,
-                Address256 dex2,
-                Address256 dex3
-            ) = abi.decode(args, (Address256, Address256, uint256, uint256, Address256, Address256, Address256));
-
-            minReturn = (minReturn * actualAmount) / amount;
-            amount = actualAmount;
-
-            return abi.encodeWithSelector(selector, to, token, amount, minReturn, dex, dex2, dex3);
-        }
-
-        if (selector == I1inchAggregationRouterV6.swap.selector) {
-            (address executor, I1inchAggregationRouterV6.SwapDescription memory desc, bytes memory data) = abi.decode(
-                args,
-                (address, I1inchAggregationRouterV6.SwapDescription, bytes)
-            );
-
-            desc.minReturnAmount = (desc.minReturnAmount * actualAmount) / desc.amount;
-            desc.amount = actualAmount;
-            return abi.encodeWithSelector(selector, executor, desc, data);
-        }
-
-        revert("1inch: unsupported selector");
-    }
-}
-
-interface I1inchAggregationRouterV6 is I1inchCommonType {
-    struct SwapDescription {
-        IERC20 srcToken;
-        IERC20 dstToken;
-        address payable srcReceiver;
-        address payable dstReceiver;
-        uint256 amount;
-        uint256 minReturnAmount;
-        uint256 flags;
-    }
-
-    // we ignore the non-to version since it's guarantee this contract won't receive tokens
-
-    function unoswapTo(
-        Address256 to,
-        Address256 token,
-        uint256 amount,
-        uint256 minReturn,
-        Address256 dex
-    ) external returns (uint256 returnAmount);
-
-    function unoswapTo2(
-        Address256 to,
-        Address256 token,
-        uint256 amount,
-        uint256 minReturn,
-        Address256 dex,
-        Address256 dex2
-    ) external returns (uint256 returnAmount);
-
-    function unoswapTo3(
-        Address256 to,
-        Address256 token,
-        uint256 amount,
-        uint256 minReturn,
-        Address256 dex,
-        Address256 dex2,
-        Address256 dex3
-    ) external returns (uint256 returnAmount);
-
-    function swap(
-        address executor,
-        SwapDescription calldata desc,
-        bytes calldata data
-    ) external payable returns (uint256 returnAmount, uint256 spentAmount);
-}