@pendle/core-v2 0.11.9-testnet → 0.11.10-testnet

package/build/artifacts/contracts/offchain-helpers/SSTORE2DeployerContract.sol/SSTORE2DeployerContract.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/20ebeca750412294184becd43b05ac5c.json"
+  "buildInfo": "../../../build-info/d246d0fd3945c2c082231b431b6c99e6.json"
 }

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -119,7 +119,12 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - _totalSupply & lastSlopeChangeAppliedAt is updated
      */
-    function totalSupplyCurrent() public virtual override returns (uint128) {
+    function totalSupplyCurrent()
+        public
+        virtual
+        override(IPVeToken, VotingEscrowTokenBase)
+        returns (uint128)
+    {
         (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }

package/contracts/core/PendleRouter.sol

@@ -51,7 +51,8 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
             sig == IPActionMintRedeem.redeemPyToToken.selector ||
             sig == IPActionMintRedeem.mintPyFromScy.selector ||
             sig == IPActionMintRedeem.redeemPyToScy.selector ||
-            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector
+            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector ||
+            sig == IPActionMintRedeem.redeemDueInterestAndRewardsThenSwapAll.selector
         ) {
             return ACTION_MINT_REDEEM;
         } else if (

package/contracts/core/actions/ActionAddRemoveLiq.sol

@@ -369,6 +369,29 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address market,
         uint256 netLpToRemove,
         uint256 minScyOut
+    ) internal returns (uint256 netScyOut) {
+        if (IPMarket(market).isExpired()) {
+            netScyOut = __removeLpToScyAfterExpiry(receiver, market, netLpToRemove);
+        } else {
+            netScyOut = __removeLpToScyBeforeExpiry(receiver, market, netLpToRemove);
+        }
+        require(netScyOut >= minScyOut, "insufficient lp out");
+    }
+
+    function __removeLpToScyAfterExpiry(
+        address receiver,
+        address market,
+        uint256 netLpToRemove
+    ) internal returns (uint256 netScyOut) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (uint256 scyFromBurn, ) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
+        netScyOut = scyFromBurn + IPYieldToken(YT).redeemPY(receiver);
+    }
+
+    function __removeLpToScyBeforeExpiry(
+        address receiver,
+        address market,
+        uint256 netLpToRemove
     ) internal returns (uint256 netScyOut) {
         (uint256 scyFromBurn, uint256 ptFromBurn) = IPMarket(market).burn(
             receiver,
@@ -380,8 +403,6 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             ptFromBurn,
             EMPTY_BYTES
         );
-
-        require(scyFromBurn + scyFromSwap >= minScyOut, "insufficient lp out");
         netScyOut = scyFromBurn + scyFromSwap;
     }
 }

package/contracts/interfaces/IPVotingEscrow.sol

@@ -5,7 +5,7 @@ pragma solidity 0.8.15;
 import "./IPVeToken.sol";
 import "../libraries/VeBalanceLib.sol";
 
-interface IPVotingEscrow {
+interface IPVotingEscrow is IPVeToken {
     event NewLockPosition(address indexed user, uint128 amount, uint128 expiry);
 
     event Withdraw(address indexed user, uint128 amount);

package/contracts/libraries/math/MarketApproxLib.sol

@@ -318,6 +318,7 @@ library MarketApproxPtInLib {
 
             uint256 netPtPayable = netAssetOut + arg.maxPtIn;
             if (guess <= netPtPayable) {
+                p.guessMin = guess;
                 uint256 netPtIn = guess - netAssetOut; // guess >= netAssetOut (market invariant)
                 if (Math.isASmallerApproxB(netPtIn, arg.maxPtIn, p.eps)) {
                     return (netAssetOut, netPtIn, guess, arg.index.assetToScy(netAssetToReserve));

package/contracts/offchain-helpers/MarketMathStatic.sol

@@ -233,15 +233,22 @@ library MarketMathStatic {
         MarketState memory state = IPMarket(market).readState();
 
         (uint256 scyFromBurn, uint256 ptFromBurn) = state.removeLiquidity(lpToRemove);
-        uint256 scyFromSwap;
-        (scyFromSwap, netScyFee) = state.swapExactPtForScy(
-            pyIndex(market),
-            ptFromBurn,
-            block.timestamp
-        );
 
-        netScyOut = scyFromBurn + scyFromSwap;
-        priceImpact = calcPriceImpact(market, ptFromBurn.neg());
+        if (IPMarket(market).isExpired()) {
+            (,, IPYieldToken YT) = IPMarket(market).readTokens(); 
+            PYIndex index = PYIndex.wrap(YT.pyIndexCurrent());
+            netScyOut = scyFromBurn + index.assetToScy(ptFromBurn);
+        } else {
+            uint256 scyFromSwap;
+            (scyFromSwap, netScyFee) = state.swapExactPtForScy(
+                pyIndex(market),
+                ptFromBurn,
+                block.timestamp
+            );
+
+            netScyOut = scyFromBurn + scyFromSwap;
+            priceImpact = calcPriceImpact(market, ptFromBurn.neg());
+        }
     }
 
     function removeLiquiditySingleBaseTokenStatic(
@@ -596,6 +603,7 @@ library MarketMathStatic {
         public
         returns (uint256)
     {
+        if (IPMarket(market).isExpired()) return Math.ONE; 
         int256 netPtToAccount = netPtOut;
         MarketState memory state = IPMarket(market).readState();
         MarketPreCompute memory comp = state.getMarketPreCompute(pyIndex(market), block.timestamp);

package/contracts/offchain-helpers/RouterStatic.sol

@@ -3,14 +3,22 @@ pragma solidity 0.8.15;
 
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
+import "../interfaces/IPVotingEscrow.sol";
+import "../periphery/BoringOwnableUpgradeable.sol";
 import "./MarketMathStatic.sol";
 import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../periphery/BoringOwnableUpgradeable.sol";
+import "../libraries/math/WeekMath.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
 contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable {
     using Math for uint256;
+    using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
+
+    uint128 public constant MAX_LOCK_TIME = 104 weeks;
+    uint128 public constant MIN_LOCK_TIME = 1 weeks;
 
     struct TokenAmount {
         address token;
@@ -47,12 +55,16 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
 
     IPYieldContractFactory internal immutable yieldContractFactory;
     IPMarketFactory internal immutable marketFactory;
+    IPVotingEscrow internal immutable vePENDLE;
 
-    constructor(IPYieldContractFactory _yieldContractFactory, IPMarketFactory _marketFactory)
-        initializer
-    {
+    constructor(
+        IPYieldContractFactory _yieldContractFactory,
+        IPMarketFactory _marketFactory,
+        IPVotingEscrow _vePENDLE
+    ) initializer {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
+        vePENDLE = _vePENDLE;
     }
 
     function initialize() external initializer {
@@ -594,6 +606,43 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         return MarketMathStatic.swapExactYtForPt(market, exactYtIn, getDefaultApproxParams());
     }
 
+    // ============= vePENDLE =============
+
+    function increaseLockPositionStatic(
+        address user,
+        uint128 additionalAmountToLock,
+        uint128 newExpiry
+    ) external view returns (uint128 newVeBalance) {
+        require(
+            WeekMath.isValidWTime(newExpiry) && !MiniHelpers.isTimeInThePast(newExpiry),
+            "invalid newExpiry"
+        );
+
+        require(newExpiry <= block.timestamp + MAX_LOCK_TIME, "max lock time exceeded");
+        require(newExpiry >= block.timestamp + MIN_LOCK_TIME, "insufficient lock time");
+
+        LockedPosition memory oldPosition;
+
+        {
+            (uint128 amount, uint128 expiry) = vePENDLE.positionData(user);
+            oldPosition = LockedPosition(amount, expiry);
+        }
+
+        require(oldPosition.expiry <= newExpiry, "new expiry must be after current expiry");
+        uint128 newTotalAmountLocked = additionalAmountToLock + oldPosition.amount;
+        require(newTotalAmountLocked > 0, "zero total amount locked");
+
+        uint128 additionalDurationToLock = newExpiry - oldPosition.expiry;
+
+        LockedPosition memory newPosition = LockedPosition(
+            oldPosition.amount + additionalAmountToLock,
+            oldPosition.expiry + additionalDurationToLock
+        );
+
+        VeBalance memory newBalance = newPosition.convertToVeBalance();
+        return newBalance.getCurrentValue();
+    }
+
     // ============= OTHER HELPERS =============
 
     function mintPYFromScyStatic(address YT, uint256 amountScyToMint)

package/package.json

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

package/typechain-types/IPVotingEscrow.ts

@@ -32,20 +32,59 @@ export type VeBalanceStructOutput = [BigNumber, BigNumber] & {
 export interface IPVotingEscrowInterface extends utils.Interface {
   contractName: "IPVotingEscrow";
   functions: {
+    "balanceOf(address)": FunctionFragment;
     "increaseLockPosition(uint128,uint128)": FunctionFragment;
+    "positionData(address)": FunctionFragment;
+    "totalSupplyAndBalanceCurrent(address)": FunctionFragment;
+    "totalSupplyCurrent()": FunctionFragment;
+    "totalSupplyStored()": FunctionFragment;
     "withdraw()": FunctionFragment;
   };
 
+  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
   encodeFunctionData(
     functionFragment: "increaseLockPosition",
     values: [BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "positionData",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupplyAndBalanceCurrent",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupplyCurrent",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalSupplyStored",
+    values?: undefined
+  ): string;
   encodeFunctionData(functionFragment: "withdraw", values?: undefined): string;
 
+  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "increaseLockPosition",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "positionData",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupplyAndBalanceCurrent",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupplyCurrent",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalSupplyStored",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;
 
   events: {
@@ -119,34 +158,90 @@ export interface IPVotingEscrow extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
+    balanceOf(user: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+
     increaseLockPosition(
       additionalAmountToLock: BigNumberish,
       expiry: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    positionData(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { amount: BigNumber; expiry: BigNumber }
+    >;
+
+    totalSupplyAndBalanceCurrent(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    totalSupplyCurrent(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    totalSupplyStored(overrides?: CallOverrides): Promise<[BigNumber]>;
+
     withdraw(
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
 
+  balanceOf(user: string, overrides?: CallOverrides): Promise<BigNumber>;
+
   increaseLockPosition(
     additionalAmountToLock: BigNumberish,
     expiry: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  positionData(
+    user: string,
+    overrides?: CallOverrides
+  ): Promise<[BigNumber, BigNumber] & { amount: BigNumber; expiry: BigNumber }>;
+
+  totalSupplyAndBalanceCurrent(
+    user: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  totalSupplyCurrent(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  totalSupplyStored(overrides?: CallOverrides): Promise<BigNumber>;
+
   withdraw(
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
+    balanceOf(user: string, overrides?: CallOverrides): Promise<BigNumber>;
+
     increaseLockPosition(
       additionalAmountToLock: BigNumberish,
       expiry: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    positionData(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { amount: BigNumber; expiry: BigNumber }
+    >;
+
+    totalSupplyAndBalanceCurrent(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber, BigNumber]>;
+
+    totalSupplyCurrent(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupplyStored(overrides?: CallOverrides): Promise<BigNumber>;
+
     withdraw(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
@@ -188,24 +283,60 @@ export interface IPVotingEscrow extends BaseContract {
   };
 
   estimateGas: {
+    balanceOf(user: string, overrides?: CallOverrides): Promise<BigNumber>;
+
     increaseLockPosition(
       additionalAmountToLock: BigNumberish,
       expiry: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    positionData(user: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalSupplyAndBalanceCurrent(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    totalSupplyCurrent(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    totalSupplyStored(overrides?: CallOverrides): Promise<BigNumber>;
+
     withdraw(
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
 
   populateTransaction: {
+    balanceOf(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     increaseLockPosition(
       additionalAmountToLock: BigNumberish,
       expiry: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    positionData(
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalSupplyAndBalanceCurrent(
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    totalSupplyCurrent(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    totalSupplyStored(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     withdraw(
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;

package/typechain-types/PendleFeeDistributorFactory.ts

@@ -27,7 +27,10 @@ export interface PendleFeeDistributorFactoryInterface extends utils.Interface {
   functions: {
     "claimOwnership()": FunctionFragment;
     "createFeeDistributor(address,uint64)": FunctionFragment;
-    "feeDistributorCreationCodePointer()": FunctionFragment;
+    "feeDistributorCreationCodeContractA()": FunctionFragment;
+    "feeDistributorCreationCodeContractB()": FunctionFragment;
+    "feeDistributorCreationCodeSizeA()": FunctionFragment;
+    "feeDistributorCreationCodeSizeB()": FunctionFragment;
     "getUserAndTotalSharesAt(address,address,uint256)": FunctionFragment;
     "lastFinishedEpoch()": FunctionFragment;
     "owner()": FunctionFragment;
@@ -50,7 +53,19 @@ export interface PendleFeeDistributorFactoryInterface extends utils.Interface {
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "feeDistributorCreationCodePointer",
+    functionFragment: "feeDistributorCreationCodeContractA",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "feeDistributorCreationCodeContractB",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "feeDistributorCreationCodeSizeA",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "feeDistributorCreationCodeSizeB",
     values?: undefined
   ): string;
   encodeFunctionData(
@@ -98,7 +113,19 @@ export interface PendleFeeDistributorFactoryInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "feeDistributorCreationCodePointer",
+    functionFragment: "feeDistributorCreationCodeContractA",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "feeDistributorCreationCodeContractB",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "feeDistributorCreationCodeSizeA",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "feeDistributorCreationCodeSizeB",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -187,10 +214,22 @@ export interface PendleFeeDistributorFactory extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    feeDistributorCreationCodePointer(
+    feeDistributorCreationCodeContractA(
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    feeDistributorCreationCodeContractB(
       overrides?: CallOverrides
     ): Promise<[string]>;
 
+    feeDistributorCreationCodeSizeA(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    feeDistributorCreationCodeSizeB(
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
     getUserAndTotalSharesAt(
       user: string,
       pool: string,
@@ -251,7 +290,21 @@ export interface PendleFeeDistributorFactory extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  feeDistributorCreationCodePointer(overrides?: CallOverrides): Promise<string>;
+  feeDistributorCreationCodeContractA(
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  feeDistributorCreationCodeContractB(
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  feeDistributorCreationCodeSizeA(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  feeDistributorCreationCodeSizeB(
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
 
   getUserAndTotalSharesAt(
     user: string,
@@ -311,10 +364,22 @@ export interface PendleFeeDistributorFactory extends BaseContract {
       overrides?: CallOverrides
     ): Promise<string>;
 
-    feeDistributorCreationCodePointer(
+    feeDistributorCreationCodeContractA(
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    feeDistributorCreationCodeContractB(
       overrides?: CallOverrides
     ): Promise<string>;
 
+    feeDistributorCreationCodeSizeA(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    feeDistributorCreationCodeSizeB(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     getUserAndTotalSharesAt(
       user: string,
       pool: string,
@@ -387,7 +452,19 @@ export interface PendleFeeDistributorFactory extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    feeDistributorCreationCodePointer(
+    feeDistributorCreationCodeContractA(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    feeDistributorCreationCodeContractB(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    feeDistributorCreationCodeSizeA(
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    feeDistributorCreationCodeSizeB(
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -443,7 +520,19 @@ export interface PendleFeeDistributorFactory extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    feeDistributorCreationCodePointer(
+    feeDistributorCreationCodeContractA(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    feeDistributorCreationCodeContractB(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    feeDistributorCreationCodeSizeA(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    feeDistributorCreationCodeSizeB(
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;