@pendle/core-v2 2.18.0 → 2.18.1

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/IMetaAggregationRouterV2.sol/IMetaAggregationRouterV2.json

@@ -0,0 +1,215 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "IMetaAggregationRouterV2",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/IMetaAggregationRouterV2.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "components": [
+            {
+              "internalType": "address",
+              "name": "callTarget",
+              "type": "address"
+            },
+            {
+              "internalType": "address",
+              "name": "approveTarget",
+              "type": "address"
+            },
+            {
+              "internalType": "bytes",
+              "name": "targetData",
+              "type": "bytes"
+            },
+            {
+              "components": [
+                {
+                  "internalType": "contract IERC20",
+                  "name": "srcToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "contract IERC20",
+                  "name": "dstToken",
+                  "type": "address"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "srcReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "srcAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address[]",
+                  "name": "feeReceivers",
+                  "type": "address[]"
+                },
+                {
+                  "internalType": "uint256[]",
+                  "name": "feeAmounts",
+                  "type": "uint256[]"
+                },
+                {
+                  "internalType": "address",
+                  "name": "dstReceiver",
+                  "type": "address"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "amount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "minReturnAmount",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "uint256",
+                  "name": "flags",
+                  "type": "uint256"
+                },
+                {
+                  "internalType": "bytes",
+                  "name": "permit",
+                  "type": "bytes"
+                }
+              ],
+              "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+              "name": "desc",
+              "type": "tuple"
+            },
+            {
+              "internalType": "bytes",
+              "name": "clientData",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMetaAggregationRouterV2.SwapExecutionParams",
+          "name": "execution",
+          "type": "tuple"
+        }
+      ],
+      "name": "swap",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "payable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "contract IAggregationExecutor",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "components": [
+            {
+              "internalType": "contract IERC20",
+              "name": "srcToken",
+              "type": "address"
+            },
+            {
+              "internalType": "contract IERC20",
+              "name": "dstToken",
+              "type": "address"
+            },
+            {
+              "internalType": "address[]",
+              "name": "srcReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "srcAmounts",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "address[]",
+              "name": "feeReceivers",
+              "type": "address[]"
+            },
+            {
+              "internalType": "uint256[]",
+              "name": "feeAmounts",
+              "type": "uint256[]"
+            },
+            {
+              "internalType": "address",
+              "name": "dstReceiver",
+              "type": "address"
+            },
+            {
+              "internalType": "uint256",
+              "name": "amount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "minReturnAmount",
+              "type": "uint256"
+            },
+            {
+              "internalType": "uint256",
+              "name": "flags",
+              "type": "uint256"
+            },
+            {
+              "internalType": "bytes",
+              "name": "permit",
+              "type": "bytes"
+            }
+          ],
+          "internalType": "struct IMetaAggregationRouterV2.SwapDescriptionV2",
+          "name": "desc",
+          "type": "tuple"
+        },
+        {
+          "internalType": "bytes",
+          "name": "executorData",
+          "type": "bytes"
+        },
+        {
+          "internalType": "bytes",
+          "name": "clientData",
+          "type": "bytes"
+        }
+      ],
+      "name": "swapSimpleMode",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol/KyberHelperEthereum.dbg.json

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

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol/KyberHelperEthereum.json

@@ -0,0 +1,10 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "KyberHelperEthereum",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol",
+  "abi": [],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.dbg.json

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

package/build/artifacts/contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol/ScaleDataHelperEthereum.json

@@ -0,0 +1,10 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "ScaleDataHelperEthereum",
+  "sourceName": "contracts/router/swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol",
+  "abi": [],
+  "bytecode": "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122042f2c9ed6176c32d6ee2a036d64e87452b186ef711dcdaaf7babaeeb5e21038964736f6c63430008110033",
+  "deployedBytecode": "0x73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122042f2c9ed6176c32d6ee2a036d64e87452b186ef711dcdaaf7babaeeb5e21038964736f6c63430008110033",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/core/StandardizedYield/implementations/PendleArbitrumStakedEthSY.sol

@@ -8,14 +8,20 @@ contract PendleArbitrumStakedEthSY is SYBase {
     using Math for int256;
 
     address public immutable chainlinkFeed;
+    address internal immutable underlyingAssetOnEthAddr;
+    uint8 internal immutable underlyingAssetOnEthDecimals;
 
     constructor(
         string memory _name,
         string memory _symbol,
         address _token,
-        address _chainlinkFeed
+        address _chainlinkFeed,
+        address _underlyingAssetOnEthAddr,
+        uint8 _underlyingAssetOnEthDecimals
     ) SYBase(_name, _symbol, _token) {
         chainlinkFeed = _chainlinkFeed;
+        underlyingAssetOnEthAddr = _underlyingAssetOnEthAddr;
+        underlyingAssetOnEthDecimals = _underlyingAssetOnEthDecimals;
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -109,6 +115,6 @@ contract PendleArbitrumStakedEthSY is SYBase {
             uint8 assetDecimals
         )
     {
-        return (AssetType.TOKEN, yieldToken, IERC20Metadata(yieldToken).decimals());
+        return (AssetType.TOKEN, underlyingAssetOnEthAddr, underlyingAssetOnEthDecimals);
     }
 }

package/contracts/interfaces/IStandardizedYield.sol

@@ -146,24 +146,29 @@ interface IStandardizedYield is IERC20Metadata {
 
     function isValidTokenOut(address token) external view returns (bool);
 
-    function previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) external view returns (uint256 amountSharesOut);
+    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        external
+        view
+        returns (uint256 amountSharesOut);
 
-    function previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) external view returns (uint256 amountTokenOut);
+    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        external
+        view
+        returns (uint256 amountTokenOut);
 
     /**
      * @notice This function contains information to interpret what the asset is
-     * @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens)
+     * @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens,
+        2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the chain)
      * @return assetAddress the address of the asset
      * @return assetDecimals the decimals of the asset
      */
     function assetInfo()
         external
         view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals);
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        );
 }

package/deployments/42161-markets/RETH-ARBITRUM-JUNE2024.json

@@ -1,9 +1,9 @@
 {
     "name": "SY rETH",
-    "SY": "0x6fa102C521da6fd5914Fc21104dc5AB9acc9f959",
-    "YT": "0x5D84A9560f928b98c735f46A300bbA99e2C6cD02",
-    "PT": "0xBc242Bd3e32209a4D3541D6CA322302acf4b4f47",
-    "market": "0x87c8D1B2ED18545594CB0417Ac2d3c2974A10912",
+    "SY": "0xc0Cf4b266bE5B3229C49590B59E67A09c15b22f4",
+    "YT": "0xe822AE44EB2466B4E263b1cbC94b4833dDEf9700",
+    "PT": "0x685155D3BD593508Fe32Be39729810A591ED9c87",
+    "market": "0x14FbC760eFaF36781cB0eb3Cb255aD976117B9Bd",
     "expiry": 1750896000,
     "scalarRoot": "112278200000000000000",
     "initAnchor": "1087110000000000000"

package/deployments/42161-markets/WSTETH-ARBITRUM-JUNE2024.json

@@ -1,9 +1,9 @@
 {
     "name": "SY wstETH",
-    "SY": "0x3635e69f1463cfFb72a3b197604CE3c0674A522c",
-    "YT": "0xf2D4Fb0c2064d3dCa388FE007579295a124Ab03a",
-    "PT": "0xB7337f35dAFf97781F5C6D5BEA396d2327f70017",
-    "market": "0x26f10da086519da50C9AF663aADCBdD96E2B308b",
+    "SY": "0x80c12D5b6Cc494632Bf11b03F09436c8B61Cc5Df",
+    "YT": "0xC8D9369809e48d03FF7B69D7979b174e2D34874C",
+    "PT": "0x1255638EFeca62e12E344E0b6B22ea853eC6e2c7",
+    "market": "0x08a152834de126d2ef83D612ff36e4523FD0017F",
     "expiry": 1750896000,
     "scalarRoot": "111711700000000000000",
     "initAnchor": "1097874000000000000"

package/package.json

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

package/typechain-types/CamelotRewardHelper.ts

@@ -7,6 +7,8 @@ import {
   BigNumberish,
   BytesLike,
   CallOverrides,
+  ContractTransaction,
+  Overrides,
   PopulatedTransaction,
   Signer,
   utils,
@@ -31,6 +33,8 @@ export interface CamelotRewardHelperInterface extends utils.Interface {
     "onNFTHarvest(address,address,uint256,uint256,uint256)": FunctionFragment;
     "onNFTWithdraw(address,uint256,uint256)": FunctionFragment;
     "positionId()": FunctionFragment;
+    "rewardTokens(uint256)": FunctionFragment;
+    "updateRewardTokensList()": FunctionFragment;
     "xGRAIL()": FunctionFragment;
     "yieldBooster()": FunctionFragment;
   };
@@ -58,6 +62,14 @@ export interface CamelotRewardHelperInterface extends utils.Interface {
     functionFragment: "positionId",
     values?: undefined
   ): string;
+  encodeFunctionData(
+    functionFragment: "rewardTokens",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "updateRewardTokensList",
+    values?: undefined
+  ): string;
   encodeFunctionData(functionFragment: "xGRAIL", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "yieldBooster",
@@ -84,6 +96,14 @@ export interface CamelotRewardHelperInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "positionId", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "rewardTokens",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "updateRewardTokensList",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "xGRAIL", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "yieldBooster",
@@ -160,6 +180,15 @@ export interface CamelotRewardHelper extends BaseContract {
 
     positionId(overrides?: CallOverrides): Promise<[BigNumber]>;
 
+    rewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    updateRewardTokensList(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     xGRAIL(overrides?: CallOverrides): Promise<[string]>;
 
     yieldBooster(overrides?: CallOverrides): Promise<[string]>;
@@ -204,6 +233,12 @@ export interface CamelotRewardHelper extends BaseContract {
 
   positionId(overrides?: CallOverrides): Promise<BigNumber>;
 
+  rewardTokens(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+
+  updateRewardTokensList(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   xGRAIL(overrides?: CallOverrides): Promise<string>;
 
   yieldBooster(overrides?: CallOverrides): Promise<string>;
@@ -248,6 +283,13 @@ export interface CamelotRewardHelper extends BaseContract {
 
     positionId(overrides?: CallOverrides): Promise<BigNumber>;
 
+    rewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    updateRewardTokensList(overrides?: CallOverrides): Promise<void>;
+
     xGRAIL(overrides?: CallOverrides): Promise<string>;
 
     yieldBooster(overrides?: CallOverrides): Promise<string>;
@@ -295,6 +337,15 @@ export interface CamelotRewardHelper extends BaseContract {
 
     positionId(overrides?: CallOverrides): Promise<BigNumber>;
 
+    rewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    updateRewardTokensList(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     xGRAIL(overrides?: CallOverrides): Promise<BigNumber>;
 
     yieldBooster(overrides?: CallOverrides): Promise<BigNumber>;
@@ -340,6 +391,15 @@ export interface CamelotRewardHelper extends BaseContract {
 
     positionId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    rewardTokens(
+      arg0: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    updateRewardTokensList(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     xGRAIL(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     yieldBooster(overrides?: CallOverrides): Promise<PopulatedTransaction>;

package/typechain-types/CamelotV1LpHelper.ts

@@ -0,0 +1,203 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  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 CamelotV1LpHelperInterface extends utils.Interface {
+  contractName: "CamelotV1LpHelper";
+  functions: {
+    "factory()": FunctionFragment;
+    "isStable()": FunctionFragment;
+    "multiplier0()": FunctionFragment;
+    "multiplier1()": FunctionFragment;
+    "pair()": FunctionFragment;
+    "referrerForSwap()": FunctionFragment;
+    "router()": FunctionFragment;
+    "token0()": FunctionFragment;
+    "token1()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
+  encodeFunctionData(functionFragment: "isStable", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "multiplier0",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "multiplier1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pair", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "referrerForSwap",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "router", values?: undefined): string;
+  encodeFunctionData(functionFragment: "token0", values?: undefined): string;
+  encodeFunctionData(functionFragment: "token1", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "isStable", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "multiplier0",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "multiplier1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pair", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "referrerForSwap",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "token0", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "token1", data: BytesLike): Result;
+
+  events: {};
+}
+
+export interface CamelotV1LpHelper extends BaseContract {
+  contractName: "CamelotV1LpHelper";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: CamelotV1LpHelperInterface;
+
+  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: {
+    factory(overrides?: CallOverrides): Promise<[string]>;
+
+    isStable(overrides?: CallOverrides): Promise<[boolean]>;
+
+    multiplier0(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    multiplier1(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    pair(overrides?: CallOverrides): Promise<[string]>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<[string]>;
+
+    router(overrides?: CallOverrides): Promise<[string]>;
+
+    token0(overrides?: CallOverrides): Promise<[string]>;
+
+    token1(overrides?: CallOverrides): Promise<[string]>;
+  };
+
+  factory(overrides?: CallOverrides): Promise<string>;
+
+  isStable(overrides?: CallOverrides): Promise<boolean>;
+
+  multiplier0(overrides?: CallOverrides): Promise<BigNumber>;
+
+  multiplier1(overrides?: CallOverrides): Promise<BigNumber>;
+
+  pair(overrides?: CallOverrides): Promise<string>;
+
+  referrerForSwap(overrides?: CallOverrides): Promise<string>;
+
+  router(overrides?: CallOverrides): Promise<string>;
+
+  token0(overrides?: CallOverrides): Promise<string>;
+
+  token1(overrides?: CallOverrides): Promise<string>;
+
+  callStatic: {
+    factory(overrides?: CallOverrides): Promise<string>;
+
+    isStable(overrides?: CallOverrides): Promise<boolean>;
+
+    multiplier0(overrides?: CallOverrides): Promise<BigNumber>;
+
+    multiplier1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pair(overrides?: CallOverrides): Promise<string>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<string>;
+
+    router(overrides?: CallOverrides): Promise<string>;
+
+    token0(overrides?: CallOverrides): Promise<string>;
+
+    token1(overrides?: CallOverrides): Promise<string>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    factory(overrides?: CallOverrides): Promise<BigNumber>;
+
+    isStable(overrides?: CallOverrides): Promise<BigNumber>;
+
+    multiplier0(overrides?: CallOverrides): Promise<BigNumber>;
+
+    multiplier1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pair(overrides?: CallOverrides): Promise<BigNumber>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<BigNumber>;
+
+    router(overrides?: CallOverrides): Promise<BigNumber>;
+
+    token0(overrides?: CallOverrides): Promise<BigNumber>;
+
+    token1(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    factory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    isStable(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    multiplier0(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    multiplier1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pair(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    referrerForSwap(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    router(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    token0(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    token1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}