@pendle/core-v2 6.1.3 → 6.1.4-sweedtest

package/contracts/offchain-helpers/MarketSweed.sol

@@ -0,0 +1,239 @@
+// 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/IMarketSweed.sol";
+
+contract MarketSweed is ActionBase, IMarketSweed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    address public immutable router;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    constructor(address _router) {
+        router = _router;
+    }
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+
+        uint256 netPtOut;
+        (netPtOut, netYtOut, guessedAmountPtToSwap) = _swap(receiver, market, tokens, sweedParams);
+
+        uint256 netYtFromSeed;
+        (netLpOut, netYtFromSeed, ) = _seed(receiver, market, tokens.SY, tokens.YT, _selfBalance(tokens.SY), netPtOut);
+        netYtOut += netYtFromSeed;
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function mintPYFromToken__noCall(
+        address YT,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPYOut) {
+        address SY = IPYieldToken(YT).SY();
+        _mintSyFromToken(YT, SY, 1, input);
+        netPYOut = IPYieldToken(YT).mintPY(msg.sender, msg.sender);
+    }
+
+    function _seed(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyMintPy) {
+        MarketState memory state = _readMarket(market);
+
+        uint256 netSyDual = 0;
+        if (netPtIn > 0) {
+            /** Add dual SY + PT */
+            uint256 netPtDual;
+            (, , netSyDual, netPtDual) = _readMarket(market).addLiquidity(netSyIn, netPtIn, block.timestamp);
+            if (netPtIn > netPtDual || netSyDual == netSyIn) {
+                revert("MS: Bought too much PT");
+            }
+            netSyIn -= netSyDual;
+            _transferOut(YT.PT(), market, netPtDual);
+        }
+
+        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);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyAddLiquidity + netSyDual);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netYtOut);
+    }
+
+    function _swap(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        ApproxSweedParams memory sweedParams
+    ) internal returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            int256 amountSyToAccount;
+
+            (guessedSwap, amountSyToAccount) = _calcAmountPtToBuy(state, index, sweedParams);
+            amountPtToAccount = guessedSwap.Uint();
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(address(this), guessedSwap.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            guessedSwap = _calcAmountPtToSell(state, index, sweedParams);
+
+            uint256 amountPtToSell = guessedSwap.abs();
+            amountYTToAccount = amountPtToSell;
+
+            _transferOut(address(tokens.SY), address(tokens.YT), index.assetToSyUp(amountPtToSell));
+            uint256 amountPYOut = tokens.YT.mintPY(market, receiver);
+
+            assert(amountPYOut >= amountPtToSell);
+
+            // 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,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, true)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount + refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return (guess, localAmountSyToAccount);
+            }
+
+            if (localState.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+                accPtToAccount += refAmt;
+            }
+        }
+        revert("_calcAmountPtToBuy: failed");
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, false)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount - refAmt;
+            }
+
+            MarketState memory localState = _deepCopy(state);
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return guess;
+            }
+
+            if (localState.lastLnImpliedRate < sweedParams.targetLnImpliedRate) {
+                accPtToAccount -= refAmt;
+            }
+        }
+        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;
+    }
+
+    function _isValidGuessOffchain(ApproxSweedParams memory sweedParams, bool isBuyingPt) internal pure returns (bool) {
+        if (sweedParams.guessOffchain == 0) return false;
+        if (isBuyingPt != (sweedParams.guessOffchain > 0)) return false;
+        return sweedParams.guessOffchain.abs() <= sweedParams.maxPtToSwap;
+    }
+}

package/contracts/router/ActionAddRemoveLiqV3.sol

@@ -15,8 +15,6 @@ contract ActionAddRemoveLiqV3 is IPActionAddRemoveLiqV3, ActionBase, ActionDeleg
     using PYIndexLib for IPYieldToken;
     using PYIndexLib for PYIndex;
 
-    constructor(address _dustReceiver) ActionDelegateBase(_dustReceiver) {}
-
     // ------------------ ADD LIQUIDITY DUAL ------------------
 
     /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.

package/contracts/router/ActionMiscV3.sol

@@ -8,8 +8,6 @@ import "../interfaces/IPReflector.sol";
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     uint256 private constant NOT_FOUND = type(uint256).max;
 
-    constructor(address _dustReceiver) ActionBase(_dustReceiver) {}
-
     function mintSyFromToken(
         address receiver,
         address SY,

package/contracts/router/ActionSimple.sol

@@ -24,8 +24,6 @@ contract ActionSimple is ActionBase, IPActionSimple {
     using PYIndexLib for PYIndex;
     using PMath for uint256;
 
-    constructor(address _dustReceiver) ActionBase(_dustReceiver) {}
-
     // ------------------ SWAP TOKEN FOR PT ------------------
     /// @notice This function is for internal router use only and should not be called directly.
     /// @dev Use swapExactTokenForPt from the main router instead.

package/contracts/router/ActionSwapPTV3.sol

@@ -8,8 +8,6 @@ import {ActionDelegateBase} from "./base/ActionDelegateBase.sol";
 contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase, ActionDelegateBase {
     using PMath for uint256;
 
-    constructor(address _dustReceiver) ActionDelegateBase(_dustReceiver) {}
-
     // ------------------ SWAP TOKEN FOR PT ------------------
     /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.
     function swapExactTokenForPt(

package/contracts/router/ActionSwapYTV3.sol

@@ -12,8 +12,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase, ActionD
     using MarketApproxPtOutLibV2 for MarketState;
     using PYIndexLib for IPYieldToken;
 
-    constructor(address _dustReceiver) ActionDelegateBase(_dustReceiver) {}
-
     // ------------------ SWAP TOKEN FOR YT ------------------
 
     /// @notice For details on the parameters (input, guessPtSwapToSy, limit, etc.), please refer to IPAllActionTypeV3.

package/contracts/router/base/ActionBase.sol

@@ -19,11 +19,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
     using PYIndexLib for PYIndex;
 
     bytes internal constant EMPTY_BYTES = abi.encode();
-    address internal immutable DUST_RECEIVER;
-
-    constructor(address _dustReceiver) {
-        DUST_RECEIVER = _dustReceiver;
-    }
 
     // ----------------- MINT REDEEM SY PY -----------------
 
@@ -163,10 +158,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
         return IPMarket(market).readState(address(this));
     }
 
-    function _sweepDust(address token) internal {
-        _transferOut(token, DUST_RECEIVER, _selfBalance(token));
-    }
-
     // ----------------- PT SWAP -----------------
 
     function _entry_swapExactPtForSy(address market, LimitOrderData calldata limit) internal view returns (address) {
@@ -193,6 +184,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netPtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, PT, netPtLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(PT), market, netPtLeft);
+            } else {
+                _transferOut(address(PT), receiver, netPtLeft);
             }
         }
 
@@ -207,8 +200,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netSyFee += netSyFeeMarket;
         }
 
-        _sweepDust(address(PT));
-
         if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
@@ -236,6 +227,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(SY), market, netSyLeft);
+            } else {
+                _transferOut(address(SY), receiver, netSyLeft);
             }
         }
 
@@ -253,8 +246,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netSyFee += netSyFeeMarket;
         }
 
-        _sweepDust(address(SY));
-
         if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
     }
 
@@ -284,6 +275,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(YT), address(YT), netYtLeft);
+            } else {
+                _transferOut(address(YT), receiver, netYtLeft);
             }
         }
 
@@ -301,8 +294,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netSyOut += SY.balanceOf(receiver) - preSyBalance;
         }
 
-        _sweepDust(address(YT));
-
         if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
     }
 
@@ -331,6 +322,8 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
             if (doMarketOrder) {
                 _transferOut(address(SY), address(YT), netSyLeft);
+            } else {
+                _transferOut(address(SY), receiver, netSyLeft);
             }
         }
 
@@ -351,7 +344,6 @@ abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
             netYtOut += netYtOutMarket;
             netSyFee += netSyFeeMarket;
         }
-        _sweepDust(address(SY));
 
         if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
     }

package/contracts/router/base/ActionDelegateBase.sol

@@ -6,8 +6,6 @@ import {IPActionSimple} from "../../interfaces/IPActionSimple.sol";
 import {ApproxParams, TokenInput, LimitOrderData} from "../../interfaces/IPAllActionTypeV3.sol";
 
 contract ActionDelegateBase is ActionBase {
-    constructor(address _dustReceiver) ActionBase(_dustReceiver) {}
-
     function delegateToAddLiquiditySinglePtSimple(
         address receiver,
         address market,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "6.1.3",
+  "version": "6.1.4-sweedtest",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/FixedPricePTAMM.ts

@@ -39,6 +39,8 @@ export interface FixedPricePTAMMInterface extends utils.Interface {
     "setPriceOracle(address,address,address,uint256)": FunctionFragment;
     "swapExactPtForToken(address,address,uint256,address,bytes)": FunctionFragment;
     "swapPtForExactToken(address,address,address,uint256,bytes)": FunctionFragment;
+    "transferInThenSwapExactPtForToken(address,address,uint256,address)": FunctionFragment;
+    "transferInThenSwapPtForExactToken(address,address,address,uint256)": FunctionFragment;
     "transferOwnership(address,bool,bool)": FunctionFragment;
     "upgradeTo(address)": FunctionFragment;
     "upgradeToAndCall(address,bytes)": FunctionFragment;
@@ -90,6 +92,14 @@ export interface FixedPricePTAMMInterface extends utils.Interface {
     functionFragment: "swapPtForExactToken",
     values: [string, string, string, BigNumberish, BytesLike]
   ): string;
+  encodeFunctionData(
+    functionFragment: "transferInThenSwapExactPtForToken",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferInThenSwapPtForExactToken",
+    values: [string, string, string, BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "transferOwnership",
     values: [string, boolean, boolean]
@@ -140,6 +150,14 @@ export interface FixedPricePTAMMInterface extends utils.Interface {
     functionFragment: "swapPtForExactToken",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferInThenSwapExactPtForToken",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferInThenSwapPtForExactToken",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "transferOwnership",
     data: BytesLike
@@ -337,6 +355,22 @@ export interface FixedPricePTAMM extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    transferInThenSwapExactPtForToken(
+      receiver: string,
+      PT: string,
+      exactPtIn: BigNumberish,
+      token: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    transferInThenSwapPtForExactToken(
+      receiver: string,
+      PT: string,
+      token: string,
+      exactTokenOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     transferOwnership(
       newOwner: string,
       direct: boolean,
@@ -429,6 +463,22 @@ export interface FixedPricePTAMM extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  transferInThenSwapExactPtForToken(
+    receiver: string,
+    PT: string,
+    exactPtIn: BigNumberish,
+    token: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  transferInThenSwapPtForExactToken(
+    receiver: string,
+    PT: string,
+    token: string,
+    exactTokenOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   transferOwnership(
     newOwner: string,
     direct: boolean,
@@ -516,6 +566,22 @@ export interface FixedPricePTAMM extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    transferInThenSwapExactPtForToken(
+      receiver: string,
+      PT: string,
+      exactPtIn: BigNumberish,
+      token: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    transferInThenSwapPtForExactToken(
+      receiver: string,
+      PT: string,
+      token: string,
+      exactTokenOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     transferOwnership(
       newOwner: string,
       direct: boolean,
@@ -680,6 +746,22 @@ export interface FixedPricePTAMM extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    transferInThenSwapExactPtForToken(
+      receiver: string,
+      PT: string,
+      exactPtIn: BigNumberish,
+      token: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    transferInThenSwapPtForExactToken(
+      receiver: string,
+      PT: string,
+      token: string,
+      exactTokenOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     transferOwnership(
       newOwner: string,
       direct: boolean,
@@ -773,6 +855,22 @@ export interface FixedPricePTAMM extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    transferInThenSwapExactPtForToken(
+      receiver: string,
+      PT: string,
+      exactPtIn: BigNumberish,
+      token: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferInThenSwapPtForExactToken(
+      receiver: string,
+      PT: string,
+      token: string,
+      exactTokenOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     transferOwnership(
       newOwner: string,
       direct: boolean,