@pendle/core-v2 0.11.9-testnet → 0.11.11-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/a07e513bae360be1bd8f008a37b5e555.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/core/actions/ActionMintRedeem.sol

@@ -187,6 +187,10 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
 
         // now swap all to outputToken
         netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
+
+        if (netTokenOut < dataSwap.minTokenOut)
+            require(netTokenOut < dataSwap.minTokenOut, "Insufficient Token Out");
+
         amountsSwapped = tokensOut.amounts;
 
         emit RedeemDueInterestAndRewardsThenSwapAll(

package/contracts/interfaces/IPActionMintRedeem.sol

@@ -147,6 +147,7 @@ interface IPActionMintRedeem {
         bytes[] kybercalls;
         //
         address outputToken;
+        uint256 minTokenOut;
     }
 
     function redeemDueInterestAndRewardsThenSwapAll(

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.11-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/ActionMintRedeem.ts

@@ -68,12 +68,19 @@ export declare namespace IPActionMintRedeem {
     tokens: string[];
     kybercalls: BytesLike[];
     outputToken: string;
+    minTokenOut: BigNumberish;
   };
 
-  export type RouterSwapAllStructStructOutput = [string[], string[], string] & {
+  export type RouterSwapAllStructStructOutput = [
+    string[],
+    string[],
+    string,
+    BigNumber
+  ] & {
     tokens: string[];
     kybercalls: string[];
     outputToken: string;
+    minTokenOut: BigNumber;
   };
 }
 
@@ -85,7 +92,7 @@ export interface ActionMintRedeemInterface extends utils.Interface {
     "mintPyFromToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "mintScyFromToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "redeemDueInterestAndRewards(address,address[],address[],address[])": FunctionFragment;
-    "redeemDueInterestAndRewardsThenSwapAll(address[],(address[],address[],address[]),address[],(address[],bytes[],address))": FunctionFragment;
+    "redeemDueInterestAndRewardsThenSwapAll(address[],(address[],address[],address[]),address[],(address[],bytes[],address,uint256))": FunctionFragment;
     "redeemPyToScy(address,address,uint256,uint256)": FunctionFragment;
     "redeemPyToToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "redeemScyToToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;

package/typechain-types/Errors.ts

@@ -0,0 +1,57 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BaseContract, Signer, utils } from "ethers";
+
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface ErrorsInterface extends utils.Interface {
+  contractName: "Errors";
+  functions: {};
+
+  events: {};
+}
+
+export interface Errors extends BaseContract {
+  contractName: "Errors";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ErrorsInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {};
+
+  callStatic: {};
+
+  filters: {};
+
+  estimateGas: {};
+
+  populateTransaction: {};
+}

package/typechain-types/ICrvPool.ts

@@ -25,23 +25,23 @@ import type {
 export interface ICrvPoolInterface extends utils.Interface {
   contractName: "ICrvPool";
   functions: {
-    "add_liquidity(uint256[],uint256,address)": FunctionFragment;
-    "calc_token_amount(uint256[],bool)": FunctionFragment;
+    "add_liquidity(uint256[2],uint256)": FunctionFragment;
+    "calc_token_amount(uint256[3],bool)": FunctionFragment;
     "calc_withdraw_one_coin(uint256,int128)": FunctionFragment;
     "exchange(int128,int128,uint256,uint256,address)": FunctionFragment;
     "get_dy(int128,int128,uint256)": FunctionFragment;
     "get_virtual_price()": FunctionFragment;
     "remove_liquidity(uint256,uint256[],address)": FunctionFragment;
-    "remove_liquidity_one_coin(uint256,int128,uint256,address)": FunctionFragment;
+    "remove_liquidity_one_coin(uint256,int128,uint256)": FunctionFragment;
   };
 
   encodeFunctionData(
     functionFragment: "add_liquidity",
-    values: [BigNumberish[], BigNumberish, string]
+    values: [[BigNumberish, BigNumberish], BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "calc_token_amount",
-    values: [BigNumberish[], boolean]
+    values: [[BigNumberish, BigNumberish, BigNumberish], boolean]
   ): string;
   encodeFunctionData(
     functionFragment: "calc_withdraw_one_coin",
@@ -65,7 +65,7 @@ export interface ICrvPoolInterface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "remove_liquidity_one_coin",
-    values: [BigNumberish, BigNumberish, BigNumberish, string]
+    values: [BigNumberish, BigNumberish, BigNumberish]
   ): string;
 
   decodeFunctionResult(
@@ -126,19 +126,43 @@ export interface ICrvPool extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    add_liquidity(
+    "add_liquidity(uint256[2],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    "add_liquidity(uint256[3],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    "add_liquidity(uint256[],uint256,address)"(
       _deposit_amount: BigNumberish[],
       _min_amount: BigNumberish,
       _receiver: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    calc_token_amount(
+    "calc_token_amount(uint256[3],bool)"(
+      _amounts: [BigNumberish, BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    "calc_token_amount(uint256[],bool)"(
       _amounts: BigNumberish[],
       _is_deposit: boolean,
       overrides?: CallOverrides
     ): Promise<[BigNumber]>;
 
+    "calc_token_amount(uint256[2],bool)"(
+      _amounts: [BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
     calc_withdraw_one_coin(
       _burn_amount: BigNumberish,
       i: BigNumberish,
@@ -174,24 +198,47 @@ export interface ICrvPool extends BaseContract {
       _burn_amount: BigNumberish,
       i: BigNumberish,
       _min_amount: BigNumberish,
-      _receiver: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
 
-  add_liquidity(
+  "add_liquidity(uint256[2],uint256)"(
+    _deposit_amount: [BigNumberish, BigNumberish],
+    _min_amount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  "add_liquidity(uint256[3],uint256)"(
+    _deposit_amount: [BigNumberish, BigNumberish, BigNumberish],
+    _min_amount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  "add_liquidity(uint256[],uint256,address)"(
     _deposit_amount: BigNumberish[],
     _min_amount: BigNumberish,
     _receiver: string,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  calc_token_amount(
+  "calc_token_amount(uint256[3],bool)"(
+    _amounts: [BigNumberish, BigNumberish, BigNumberish],
+    _is_deposit: boolean,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  "calc_token_amount(uint256[],bool)"(
     _amounts: BigNumberish[],
     _is_deposit: boolean,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  "calc_token_amount(uint256[2],bool)"(
+    _amounts: [BigNumberish, BigNumberish],
+    _is_deposit: boolean,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
   calc_withdraw_one_coin(
     _burn_amount: BigNumberish,
     i: BigNumberish,
@@ -227,24 +274,47 @@ export interface ICrvPool extends BaseContract {
     _burn_amount: BigNumberish,
     i: BigNumberish,
     _min_amount: BigNumberish,
-    _receiver: string,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    add_liquidity(
+    "add_liquidity(uint256[2],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    "add_liquidity(uint256[3],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    "add_liquidity(uint256[],uint256,address)"(
       _deposit_amount: BigNumberish[],
       _min_amount: BigNumberish,
       _receiver: string,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    calc_token_amount(
+    "calc_token_amount(uint256[3],bool)"(
+      _amounts: [BigNumberish, BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "calc_token_amount(uint256[],bool)"(
       _amounts: BigNumberish[],
       _is_deposit: boolean,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "calc_token_amount(uint256[2],bool)"(
+      _amounts: [BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     calc_withdraw_one_coin(
       _burn_amount: BigNumberish,
       i: BigNumberish,
@@ -280,27 +350,50 @@ export interface ICrvPool extends BaseContract {
       _burn_amount: BigNumberish,
       i: BigNumberish,
       _min_amount: BigNumberish,
-      _receiver: string,
       overrides?: CallOverrides
-    ): Promise<BigNumber>;
+    ): Promise<void>;
   };
 
   filters: {};
 
   estimateGas: {
-    add_liquidity(
+    "add_liquidity(uint256[2],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    "add_liquidity(uint256[3],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    "add_liquidity(uint256[],uint256,address)"(
       _deposit_amount: BigNumberish[],
       _min_amount: BigNumberish,
       _receiver: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    calc_token_amount(
+    "calc_token_amount(uint256[3],bool)"(
+      _amounts: [BigNumberish, BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "calc_token_amount(uint256[],bool)"(
       _amounts: BigNumberish[],
       _is_deposit: boolean,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "calc_token_amount(uint256[2],bool)"(
+      _amounts: [BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     calc_withdraw_one_coin(
       _burn_amount: BigNumberish,
       i: BigNumberish,
@@ -336,25 +429,48 @@ export interface ICrvPool extends BaseContract {
       _burn_amount: BigNumberish,
       i: BigNumberish,
       _min_amount: BigNumberish,
-      _receiver: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    add_liquidity(
+    "add_liquidity(uint256[2],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    "add_liquidity(uint256[3],uint256)"(
+      _deposit_amount: [BigNumberish, BigNumberish, BigNumberish],
+      _min_amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    "add_liquidity(uint256[],uint256,address)"(
       _deposit_amount: BigNumberish[],
       _min_amount: BigNumberish,
       _receiver: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    calc_token_amount(
+    "calc_token_amount(uint256[3],bool)"(
+      _amounts: [BigNumberish, BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "calc_token_amount(uint256[],bool)"(
       _amounts: BigNumberish[],
       _is_deposit: boolean,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "calc_token_amount(uint256[2],bool)"(
+      _amounts: [BigNumberish, BigNumberish],
+      _is_deposit: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     calc_withdraw_one_coin(
       _burn_amount: BigNumberish,
       i: BigNumberish,
@@ -390,7 +506,6 @@ export interface ICrvPool extends BaseContract {
       _burn_amount: BigNumberish,
       i: BigNumberish,
       _min_amount: BigNumberish,
-      _receiver: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
   };

package/typechain-types/IPActionMintRedeem.ts

@@ -68,12 +68,19 @@ export declare namespace IPActionMintRedeem {
     tokens: string[];
     kybercalls: BytesLike[];
     outputToken: string;
+    minTokenOut: BigNumberish;
   };
 
-  export type RouterSwapAllStructStructOutput = [string[], string[], string] & {
+  export type RouterSwapAllStructStructOutput = [
+    string[],
+    string[],
+    string,
+    BigNumber
+  ] & {
     tokens: string[];
     kybercalls: string[];
     outputToken: string;
+    minTokenOut: BigNumber;
   };
 }
 
@@ -84,7 +91,7 @@ export interface IPActionMintRedeemInterface extends utils.Interface {
     "mintPyFromToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "mintScyFromToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "redeemDueInterestAndRewards(address,address[],address[],address[])": FunctionFragment;
-    "redeemDueInterestAndRewardsThenSwapAll(address[],(address[],address[],address[]),address[],(address[],bytes[],address))": FunctionFragment;
+    "redeemDueInterestAndRewardsThenSwapAll(address[],(address[],address[],address[]),address[],(address[],bytes[],address,uint256))": FunctionFragment;
     "redeemPyToScy(address,address,uint256,uint256)": FunctionFragment;
     "redeemPyToToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "redeemScyToToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;