@pendle/core-v2 4.0.4 → 4.0.6

package/contracts/router/swap-aggregator/kyberswap/l1-contracts/InputScalingHelper.sol

@@ -248,6 +248,20 @@ library InputScalingHelper {
                 swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because Solidly V2 and Mantis have same fields
             } else if (functionSelector == IExecutorHelper.executeKokonut.selector) {
                 swap.data = ScalingDataLib.newKokonut(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBalancerV1.selector) {
+                swap.data = ScalingDataLib.newBalancerV1(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeSwaapV2.selector) {
+                revert("InputScalingHelper: Can not scale SwaapV2 swap");
+            } else if (functionSelector == IExecutorHelper.executeNomiswapStable.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because NomiswapV2 and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeArbswapStable.selector) {
+                swap.data = ScalingDataLib.newArbswapStable(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBancorV2.selector) {
+                swap.data = ScalingDataLib.newBancorV2(swap.data, oldAmount, newAmount);
+            } else if (functionSelector == IExecutorHelper.executeBancorV3.selector) {
+                swap.data = ScalingDataLib.newMantis(swap.data, oldAmount, newAmount); // @dev using Mantis struct because Bancor V3 and Mantis have same fields
+            } else if (functionSelector == IExecutorHelper.executeAmbient.selector) {
+                swap.data = ScalingDataLib.newAmbient(swap.data, oldAmount, newAmount);
             } else {
                 revert("AggregationExecutor: Dex type not supported");
             }

package/contracts/router/swap-aggregator/kyberswap/l1-contracts/ScalingDataLib.sol

@@ -241,4 +241,36 @@ library ScalingDataLib {
         kokonut.dx = (kokonut.dx * newAmount) / oldAmount;
         return abi.encode(kokonut);
     }
+
+    function newBalancerV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.BalancerV1 memory balancerV1 = abi.decode(data, (IExecutorHelper.BalancerV1));
+        balancerV1.amount = (balancerV1.amount * newAmount) / oldAmount;
+        return abi.encode(balancerV1);
+    }
+
+    function newArbswapStable(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper.ArbswapStable memory arbswapStable = abi.decode(data, (IExecutorHelper.ArbswapStable));
+        arbswapStable.dx = (arbswapStable.dx * newAmount) / oldAmount;
+        return abi.encode(arbswapStable);
+    }
+
+    function newBancorV2(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.BancorV2 memory bancorV2 = abi.decode(data, (IExecutorHelper.BancorV2));
+        bancorV2.amount = (bancorV2.amount * newAmount) / oldAmount;
+        return abi.encode(bancorV2);
+    }
+
+    function newAmbient(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        IExecutorHelper.Ambient memory ambient = abi.decode(data, (IExecutorHelper.Ambient));
+        ambient.qty = uint128((uint256(ambient.qty) * newAmount) / oldAmount);
+        return abi.encode(ambient);
+    }
 }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/CalldataReader.sol

@@ -55,6 +55,12 @@ library CalldataReader {
         return (uint32(bytes4(ret)), startByte);
     }
 
+    function _readUint128(bytes memory data, uint256 startByte) internal pure returns (uint128, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 16);
+        return (uint128(bytes16(ret)), startByte);
+    }
+
     function _readUint160(bytes memory data, uint256 startByte) internal pure returns (uint160, uint256) {
         bytes memory ret;
         (ret, startByte) = _calldataVal(data, startByte, 20);

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/DexScaler.sol

@@ -361,9 +361,8 @@ library DexScaler {
 
         (, startByte) = data._readPool(startByte); // pool
 
-        (, startByte) = data._readAddress(startByte); // tokenOut
-
         (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleVelocoreV2");
     }
 
@@ -379,4 +378,62 @@ library DexScaler {
         (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleKokonut");
     }
+
+    function scaleBalancerV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleBalancerV1");
+    }
+
+    function scaleArbswapStable(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint256 dx, ) = data._readUint128AsUint256(startByte); // dx
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (dx * newAmount) / oldAmount, "scaleArbswapStable");
+    }
+
+    function scaleBancorV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddressArray(startByte); // swapPath
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleBancorV2");
+    }
+
+    function scaleAmbient(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint128 qty, ) = data._readUint128(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (qty * newAmount) / oldAmount, "scaleAmbient");
+    }
 }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/InputScalingHelperL2.sol

@@ -62,7 +62,14 @@ library InputScalingHelperL2 {
         VelocoreV2,
         Smardex,
         SolidlyV2,
-        Kokonut
+        Kokonut,
+        BalancerV1,
+        SwaapV2,
+        NomiswapStable,
+        ArbswapStable,
+        BancorV2,
+        BancorV3,
+        Ambient
     }
 
     function _getScaledInputData(bytes calldata inputData, uint256 newAmount) internal pure returns (bytes memory) {
@@ -317,6 +324,20 @@ library InputScalingHelperL2 {
             swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Kokonut) {
             swap.data = swap.data.newKokonut(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerV1) {
+            swap.data = swap.data.newBalancerV1(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.SwaapV2) {
+            revert("InputScalingHelper: Can not scale SwaapV2 swap");
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.NomiswapStable) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.ArbswapStable) {
+            swap.data = swap.data.newArbswapStable(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BancorV2) {
+            swap.data = swap.data.newBancorV2(oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.BancorV3) {
+            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Ambient) {
+            swap.data = swap.data.newAmbient(oldAmount, newAmount);
         } else {
             revert("InputScaleHelper: Dex type not supported");
         }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/ScalingDataL2Lib.sol

@@ -170,4 +170,28 @@ library ScalingDataL2Lib {
     function newKokonut(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
         return data.scaleKokonut(oldAmount, newAmount);
     }
+
+    function newBalancerV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleBalancerV1(oldAmount, newAmount);
+    }
+
+    function newArbswapStable(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleArbswapStable(oldAmount, newAmount);
+    }
+
+    function newBancorV2(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleBancorV2(oldAmount, newAmount);
+    }
+
+    function newAmbient(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleAmbient(oldAmount, newAmount);
+    }
 }

package/deployments/1-core.json

@@ -24,7 +24,7 @@
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
     "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x324D838b26Eb73786bDBBc53bb0682F1EBB50603",
+    "pendleSwap": "0x1f5B1f22585f430C3a1a7D16e1E1100945965e35",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "ptOracle": "0xbbd487268A295531d299c125F3e5f749884A3e30",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",

package/deployments/10-core.json

@@ -21,7 +21,7 @@
     "marketFactory": "0x17F100fB4bE2707675c6439468d38249DD993d58",
     "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x704478Dd72FD7F9B83d1F1e0fc18C14B54F034d0",
-    "pendleSwap": "0x85D0C209FC632e6908D78BE08646dE3e39A58453",
+    "pendleSwap": "0x7076dEE976098B444f68C6382E8f062237879a9F",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "ptOracle": "0x0b692f06CA82e3075dC537224450885Fd138e655",
     "externalRewardDistributor": "0x1fBaCedf510dAA79dfD9B41227A7ba192d5D548D",

package/deployments/42161-core.json

@@ -21,7 +21,7 @@
     "marketFactory": "0xf5a7De2D276dbda3EEf1b62A9E718EFf4d29dDC8",
     "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0xAdB09F65bd90d19e3148D9ccb693F3161C6DB3E8",
-    "pendleSwap": "0x8e09Aa43885d99701AB047dA2aC98aECC13807B0",
+    "pendleSwap": "0x1f5B1f22585f430C3a1a7D16e1E1100945965e35",
     "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
     "ptOracle": "0x7e16e4253CE4a1C96422a9567B23b4b5Ebc207F1",
     "yieldContractFactoryV3": "0xEb38531db128EcA928aea1B1CE9E5609B15ba146",

package/deployments/56-core.json

@@ -21,7 +21,7 @@
     "marketFactory": "0x2bEa6BfD8fbFF45aA2a893EB3B6d85D10EFcC70E",
     "router": "0x00000000005BBB0EF59571E58418F9a4357b68A0",
     "routerStatic": "0x2700ADB035F82a11899ce1D3f1BF8451c296eABb",
-    "pendleSwap": "0xD85d2F484DF4329746325e7398f3fC3E1915a173",
+    "pendleSwap": "0x8536b3519eaE59741B340bccE6c522c545606C59",
     "routerHelper": "0x09D65812dCD0f276e052583d41885cA5C7Dd0086",
     "ptOracle": "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD",
     "yieldContractFactoryV3": "0x40Ae6da2d92aa3DCb7f8d7a7209FD12BDfcb7C85",

package/package.json

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

package/typechain-types/ActionAddRemoveLiqV3.ts

@@ -472,9 +472,9 @@ export type AddLiquiditySingleTokenKeepYtEvent = TypedEvent<
     token: string;
     receiver: string;
     netTokenIn: BigNumber;
-    netSyMintPy: BigNumber;
     netLpOut: BigNumber;
     netYtOut: BigNumber;
+    netSyMintPy: BigNumber;
     netSyInterm: BigNumber;
   }
 >;
@@ -1091,9 +1091,9 @@ export interface ActionAddRemoveLiqV3 extends BaseContract {
       token?: string | null,
       receiver?: null,
       netTokenIn?: null,
-      netSyMintPy?: null,
       netLpOut?: null,
       netYtOut?: null,
+      netSyMintPy?: null,
       netSyInterm?: null
     ): AddLiquiditySingleTokenKeepYtEventFilter;
     AddLiquiditySingleTokenKeepYt(
@@ -1102,9 +1102,9 @@ export interface ActionAddRemoveLiqV3 extends BaseContract {
       token?: string | null,
       receiver?: null,
       netTokenIn?: null,
-      netSyMintPy?: null,
       netLpOut?: null,
       netYtOut?: null,
+      netSyMintPy?: null,
       netSyInterm?: null
     ): AddLiquiditySingleTokenKeepYtEventFilter;
 

package/typechain-types/IEtherFiLiquidityPool.ts

@@ -0,0 +1,291 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  PayableOverrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface IEtherFiLiquidityPoolInterface extends utils.Interface {
+  contractName: "IEtherFiLiquidityPool";
+  functions: {
+    "amountForShare(uint256)": FunctionFragment;
+    "deposit(address)": FunctionFragment;
+    "getTotalEtherClaimOf(address)": FunctionFragment;
+    "getTotalPooledEther()": FunctionFragment;
+    "sharesForAmount(uint256)": FunctionFragment;
+    "sharesForWithdrawalAmount(uint256)": FunctionFragment;
+    "totalValueInLp()": FunctionFragment;
+    "totalValueOutOfLp()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "amountForShare",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(functionFragment: "deposit", values: [string]): string;
+  encodeFunctionData(
+    functionFragment: "getTotalEtherClaimOf",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getTotalPooledEther",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "sharesForAmount",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "sharesForWithdrawalAmount",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalValueInLp",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "totalValueOutOfLp",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "amountForShare",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getTotalEtherClaimOf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getTotalPooledEther",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "sharesForAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "sharesForWithdrawalAmount",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalValueInLp",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "totalValueOutOfLp",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IEtherFiLiquidityPool extends BaseContract {
+  contractName: "IEtherFiLiquidityPool";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IEtherFiLiquidityPoolInterface;
+
+  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: {
+    amountForShare(
+      _share: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    deposit(
+      _referral: string,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getTotalEtherClaimOf(
+      _user: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    getTotalPooledEther(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    sharesForAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    sharesForWithdrawalAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    totalValueInLp(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    totalValueOutOfLp(overrides?: CallOverrides): Promise<[BigNumber]>;
+  };
+
+  amountForShare(
+    _share: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  deposit(
+    _referral: string,
+    overrides?: PayableOverrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getTotalEtherClaimOf(
+    _user: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getTotalPooledEther(overrides?: CallOverrides): Promise<BigNumber>;
+
+  sharesForAmount(
+    _amount: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  sharesForWithdrawalAmount(
+    _amount: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  totalValueInLp(overrides?: CallOverrides): Promise<BigNumber>;
+
+  totalValueOutOfLp(overrides?: CallOverrides): Promise<BigNumber>;
+
+  callStatic: {
+    amountForShare(
+      _share: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    deposit(_referral: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    getTotalEtherClaimOf(
+      _user: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getTotalPooledEther(overrides?: CallOverrides): Promise<BigNumber>;
+
+    sharesForAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    sharesForWithdrawalAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalValueInLp(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalValueOutOfLp(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    amountForShare(
+      _share: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    deposit(
+      _referral: string,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    getTotalEtherClaimOf(
+      _user: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getTotalPooledEther(overrides?: CallOverrides): Promise<BigNumber>;
+
+    sharesForAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    sharesForWithdrawalAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    totalValueInLp(overrides?: CallOverrides): Promise<BigNumber>;
+
+    totalValueOutOfLp(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    amountForShare(
+      _share: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    deposit(
+      _referral: string,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getTotalEtherClaimOf(
+      _user: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getTotalPooledEther(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    sharesForAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    sharesForWithdrawalAmount(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    totalValueInLp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    totalValueOutOfLp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}