@pendle/core-v2 1.0.0-mainnet → 1.0.1-mainnet

package/contracts/offchain-helpers/RouterStatic.sol

@@ -14,9 +14,10 @@ import "../LiquidityMining/libraries/VeBalanceLib.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable {
+contract RouterStatic is Initializable, Proxy, BoringOwnableUpgradeable, UUPSUpgradeable {
     using Math for uint256;
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -62,32 +63,29 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     IPMarketFactory internal immutable marketFactory;
     IPVotingEscrowMainchain internal immutable vePENDLE;
     IPBulkSellerFactory internal immutable bulkFactory;
+    address internal immutable marketMathStaticLib;
 
     constructor(
         IPYieldContractFactory _yieldContractFactory,
         IPMarketFactory _marketFactory,
         IPVotingEscrowMainchain _vePENDLE,
-        IPBulkSellerFactory _bulkFactory
+        IPBulkSellerFactory _bulkFactory,
+        address _marketMathStaticLib
     ) initializer {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
         vePENDLE = _vePENDLE;
         bulkFactory = _bulkFactory;
+        marketMathStaticLib = _marketMathStaticLib;
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    // all Market-related functions will go to MarketMathStaticLib
+    function _implementation() internal view override returns (address) {
+        return marketMathStaticLib;
     }
 
-    function getDefaultApproxParams() public pure returns (ApproxParams memory) {
-        return
-            ApproxParams({
-                guessMin: 0,
-                guessMax: type(uint256).max,
-                guessOffchain: 0,
-                maxIteration: 256,
-                eps: 1e14
-            });
+    function initialize() external initializer {
+        __BoringOwnable_init();
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
@@ -158,7 +156,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         sy = address(SY);
         state = _market.readState(address(this));
         impliedYield = getPtImpliedYield(market);
-        exchangeRate = MarketMathStatic.getExchangeRate(market);
+        exchangeRate = MarketMathStatic.getTradeExchangeRateExcludeFee(market);
     }
 
     // ============= USER INFO =============
@@ -325,11 +323,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netLpOut,
             uint256 netPtToSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.addLiquiditySinglePtStatic(market, netPtIn, getDefaultApproxParams());
+        return MarketMathStatic.addLiquiditySinglePtStatic(market, netPtIn);
     }
 
     function addLiquiditySingleSyStatic(address market, uint256 netSyIn)
@@ -338,11 +336,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netLpOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn);
     }
 
     function addLiquiditySingleBaseTokenStatic(
@@ -356,7 +354,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netLpOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyIn = previewDepositStatic(
@@ -366,8 +365,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             bulk
         );
 
-        return
-            MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn);
     }
 
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
@@ -400,15 +398,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netPtOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.removeLiquiditySinglePtStatic(
-                market,
-                netLpToRemove,
-                getDefaultApproxParams()
-            );
+        return MarketMathStatic.removeLiquiditySinglePtStatic(market, netLpToRemove);
     }
 
     function removeLiquiditySingleSyStatic(address market, uint256 netLpToRemove)
@@ -416,7 +410,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.removeLiquiditySingleSyStatic(market, netLpToRemove);
@@ -432,15 +427,14 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netBaseTokenOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyOut;
 
-        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.removeLiquiditySingleSyStatic(
-            market,
-            netLpToRemove
-        );
+        (netSyOut, netSyFee, priceImpact, exchangeRateAfter) = MarketMathStatic
+            .removeLiquiditySingleSyStatic(market, netLpToRemove);
 
         netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, bulk);
     }
@@ -450,7 +444,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapExactPtForSyStatic(market, exactPtIn);
@@ -461,7 +456,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapSyForExactPtStatic(market, exactPtOut);
@@ -472,11 +468,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netPtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapExactSyForPtStatic(market, exactSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForPtStatic(market, exactSyIn);
     }
 
     function swapPtForExactSyStatic(address market, uint256 exactSyOut)
@@ -484,11 +480,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netPtIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapPtForExactSyStatic(market, exactSyOut, getDefaultApproxParams());
+        return MarketMathStatic.swapPtForExactSyStatic(market, exactSyOut);
     }
 
     function swapExactBaseTokenForPtStatic(
@@ -501,7 +497,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netPtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyIn = previewDepositStatic(
@@ -510,7 +507,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             amountBaseToken,
             bulk
         );
-        return MarketMathStatic.swapExactSyForPtStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForPtStatic(market, netSyIn);
     }
 
     function swapExactPtForBaseTokenStatic(
@@ -523,14 +520,13 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netBaseTokenOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyOut;
-        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.swapExactPtForSyStatic(
-            market,
-            exactPtIn
-        );
+        (netSyOut, netSyFee, priceImpact, exchangeRateAfter) = MarketMathStatic
+            .swapExactPtForSyStatic(market, exactPtIn);
 
         netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, bulk);
     }
@@ -540,7 +536,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapSyForExactYtStatic(market, exactYtOut);
@@ -551,11 +548,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netYtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapExactSyForYtStatic(market, exactSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForYtStatic(market, exactSyIn);
     }
 
     function swapExactYtForSyStatic(address market, uint256 exactYtIn)
@@ -563,7 +560,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapExactYtForSyStatic(market, exactYtIn);
@@ -574,11 +572,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netYtIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapYtForExactSyStatic(market, exactSyOut, getDefaultApproxParams());
+        return MarketMathStatic.swapYtForExactSyStatic(market, exactSyOut);
     }
 
     function swapExactYtForBaseTokenStatic(
@@ -591,14 +589,13 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netBaseTokenOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyOut;
-        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.swapExactYtForSyStatic(
-            market,
-            exactYtIn
-        );
+        (netSyOut, netSyFee, priceImpact, exchangeRateAfter) = MarketMathStatic
+            .swapExactYtForSyStatic(market, exactYtIn);
 
         netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, bulk);
     }
@@ -613,7 +610,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netYtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyIn = previewDepositStatic(
@@ -623,7 +621,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             bulk
         );
 
-        return MarketMathStatic.swapExactSyForYtStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForYtStatic(market, netSyIn);
     }
 
     function swapExactPtForYtStatic(address market, uint256 exactPtIn)
@@ -632,10 +630,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netYtOut,
             uint256 totalPtToSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return MarketMathStatic.swapExactPtForYt(market, exactPtIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactPtForYt(market, exactPtIn);
     }
 
     function swapExactYtForPtStatic(address market, uint256 exactYtIn)
@@ -644,10 +643,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netPtOut,
             uint256 totalPtSwapped,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return MarketMathStatic.swapExactYtForPt(market, exactYtIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactYtForPt(market, exactYtIn);
     }
 
     // ============= vePENDLE =============
@@ -778,7 +778,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         public
         returns (uint256 priceImpact)
     {
-        return MarketMathStatic.calcPriceImpact(market, netPtOut);
+        return MarketMathStatic.calcPriceImpactPt(market, netPtOut);
     }
 
     // either but not both pyToken or market must be != 0
@@ -803,7 +803,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         address bulk,
         uint256 netSyOut
     ) public view returns (uint256 netTokenIn) {
-        uint256 pivotAmount = netSyOut;
+        uint256 pivotAmount = 10**IERC20Metadata(tokenIn).decimals();
 
         uint256 low = pivotAmount;
         {

package/deployments/1-core.json

@@ -21,7 +21,7 @@
     "bulkSellerFactory": "0x4B1da107B50529d53e5C906a79eaEcDCbC0E1dE3",
     "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
     "router": "0x41FAD93F225b5C1C95f2445A5d7fcB85bA46713f",
-    "routerStatic": "0x83cDf16B491d629C7C64d373BA0C767981e3B352",
+    "routerStatic": "0xcF45b92cd0B0859FC42a767fAac2354909f937e9",
     "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
     "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
     "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",

package/package.json

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

package/typechain-types/IApeStaking.ts

@@ -0,0 +1,274 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  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 IApeStakingInterface extends utils.Interface {
+  contractName: "IApeStaking";
+  functions: {
+    "addressPosition(address)": FunctionFragment;
+    "apeCoin()": FunctionFragment;
+    "claimSelfApeCoin()": FunctionFragment;
+    "depositSelfApeCoin(uint256)": FunctionFragment;
+    "pendingRewards(uint256,address,uint256)": FunctionFragment;
+    "withdrawApeCoin(uint256,address)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "addressPosition",
+    values: [string]
+  ): string;
+  encodeFunctionData(functionFragment: "apeCoin", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "claimSelfApeCoin",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "depositSelfApeCoin",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pendingRewards",
+    values: [BigNumberish, string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "withdrawApeCoin",
+    values: [BigNumberish, string]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "addressPosition",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "apeCoin", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "claimSelfApeCoin",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "depositSelfApeCoin",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "pendingRewards",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "withdrawApeCoin",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface IApeStaking extends BaseContract {
+  contractName: "IApeStaking";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IApeStakingInterface;
+
+  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: {
+    addressPosition(
+      addr: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        stakedAmount: BigNumber;
+        rewardsDebt: BigNumber;
+      }
+    >;
+
+    apeCoin(overrides?: CallOverrides): Promise<[string]>;
+
+    claimSelfApeCoin(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    depositSelfApeCoin(
+      _amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    pendingRewards(
+      _poolId: BigNumberish,
+      _address: string,
+      _tokenId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber]>;
+
+    withdrawApeCoin(
+      _amount: BigNumberish,
+      _recipient: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  addressPosition(
+    addr: string,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { stakedAmount: BigNumber; rewardsDebt: BigNumber }
+  >;
+
+  apeCoin(overrides?: CallOverrides): Promise<string>;
+
+  claimSelfApeCoin(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  depositSelfApeCoin(
+    _amount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  pendingRewards(
+    _poolId: BigNumberish,
+    _address: string,
+    _tokenId: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  withdrawApeCoin(
+    _amount: BigNumberish,
+    _recipient: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    addressPosition(
+      addr: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & {
+        stakedAmount: BigNumber;
+        rewardsDebt: BigNumber;
+      }
+    >;
+
+    apeCoin(overrides?: CallOverrides): Promise<string>;
+
+    claimSelfApeCoin(overrides?: CallOverrides): Promise<void>;
+
+    depositSelfApeCoin(
+      _amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    pendingRewards(
+      _poolId: BigNumberish,
+      _address: string,
+      _tokenId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    withdrawApeCoin(
+      _amount: BigNumberish,
+      _recipient: string,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    addressPosition(
+      addr: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    apeCoin(overrides?: CallOverrides): Promise<BigNumber>;
+
+    claimSelfApeCoin(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    depositSelfApeCoin(
+      _amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    pendingRewards(
+      _poolId: BigNumberish,
+      _address: string,
+      _tokenId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    withdrawApeCoin(
+      _amount: BigNumberish,
+      _recipient: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    addressPosition(
+      addr: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    apeCoin(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    claimSelfApeCoin(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    depositSelfApeCoin(
+      _amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    pendingRewards(
+      _poolId: BigNumberish,
+      _address: string,
+      _tokenId: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    withdrawApeCoin(
+      _amount: BigNumberish,
+      _recipient: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}