@pendle/core-v2 1.4.0-mainnet → 1.4.1-testnet

package/typechain-types/IPRouterStatic.ts

@@ -13,7 +13,7 @@ import {
   Signer,
   utils,
 } from "ethers";
-import { FunctionFragment, Result } from "@ethersproject/abi";
+import { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
 import { Listener, Provider } from "@ethersproject/providers";
 import type {
   TypedEventFilter,
@@ -22,57 +22,63 @@ import type {
   OnEvent,
 } from "./common";
 
+export type ApproxParamsStruct = {
+  guessMin: BigNumberish;
+  guessMax: BigNumberish;
+  guessOffchain: BigNumberish;
+  maxIteration: BigNumberish;
+  eps: BigNumberish;
+};
+
+export type ApproxParamsStructOutput = [
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber,
+  BigNumber
+] & {
+  guessMin: BigNumber;
+  guessMax: BigNumber;
+  guessOffchain: BigNumber;
+  maxIteration: BigNumber;
+  eps: BigNumber;
+};
+
 export type MarketStateStruct = {
   totalPt: BigNumberish;
-  totalScy: BigNumberish;
+  totalSy: BigNumberish;
   totalLp: BigNumberish;
-  oracleRate: BigNumberish;
   treasury: string;
   scalarRoot: BigNumberish;
-  lnFeeRateRoot: BigNumberish;
-  rateOracleTimeWindow: BigNumberish;
   expiry: BigNumberish;
+  lnFeeRateRoot: BigNumberish;
   reserveFeePercent: BigNumberish;
   lastLnImpliedRate: BigNumberish;
-  lastTradeTime: BigNumberish;
 };
 
 export type MarketStateStructOutput = [
   BigNumber,
   BigNumber,
   BigNumber,
-  BigNumber,
   string,
   BigNumber,
   BigNumber,
   BigNumber,
   BigNumber,
-  BigNumber,
-  BigNumber,
   BigNumber
 ] & {
   totalPt: BigNumber;
-  totalScy: BigNumber;
+  totalSy: BigNumber;
   totalLp: BigNumber;
-  oracleRate: BigNumber;
   treasury: string;
   scalarRoot: BigNumber;
-  lnFeeRateRoot: BigNumber;
-  rateOracleTimeWindow: BigNumber;
   expiry: BigNumber;
+  lnFeeRateRoot: BigNumber;
   reserveFeePercent: BigNumber;
   lastLnImpliedRate: BigNumber;
-  lastTradeTime: BigNumber;
 };
 
-export declare namespace IPRouterStatic {
-  export type RewardIndexStruct = { rewardToken: string; index: BigNumberish };
-
-  export type RewardIndexStructOutput = [string, BigNumber] & {
-    rewardToken: string;
-    index: BigNumber;
-  };
-
+export declare namespace IPActionInfoStatic {
   export type TokenAmountStruct = { token: string; amount: BigNumberish };
 
   export type TokenAmountStructOutput = [string, BigNumber] & {
@@ -80,172 +86,435 @@ export declare namespace IPRouterStatic {
     amount: BigNumber;
   };
 
-  export type AssetAmountStruct = {
-    assetType: BigNumberish;
-    assetAddress: string;
-    amount: BigNumberish;
-  };
-
-  export type AssetAmountStructOutput = [number, string, BigNumber] & {
-    assetType: number;
-    assetAddress: string;
-    amount: BigNumber;
-  };
-
   export type UserMarketInfoStruct = {
-    market: string;
-    lpBalance: BigNumberish;
-    ptBalance: IPRouterStatic.TokenAmountStruct;
-    scyBalance: IPRouterStatic.TokenAmountStruct;
-    assetBalance: IPRouterStatic.AssetAmountStruct;
+    lpBalance: IPActionInfoStatic.TokenAmountStruct;
+    ptBalance: IPActionInfoStatic.TokenAmountStruct;
+    syBalance: IPActionInfoStatic.TokenAmountStruct;
+    unclaimedRewards: IPActionInfoStatic.TokenAmountStruct[];
   };
 
   export type UserMarketInfoStructOutput = [
-    string,
-    BigNumber,
-    IPRouterStatic.TokenAmountStructOutput,
-    IPRouterStatic.TokenAmountStructOutput,
-    IPRouterStatic.AssetAmountStructOutput
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput[]
   ] & {
-    market: string;
-    lpBalance: BigNumber;
-    ptBalance: IPRouterStatic.TokenAmountStructOutput;
-    scyBalance: IPRouterStatic.TokenAmountStructOutput;
-    assetBalance: IPRouterStatic.AssetAmountStructOutput;
+    lpBalance: IPActionInfoStatic.TokenAmountStructOutput;
+    ptBalance: IPActionInfoStatic.TokenAmountStructOutput;
+    syBalance: IPActionInfoStatic.TokenAmountStructOutput;
+    unclaimedRewards: IPActionInfoStatic.TokenAmountStructOutput[];
   };
 
   export type UserPYInfoStruct = {
-    yt: string;
-    pt: string;
-    ytBalance: BigNumberish;
-    ptBalance: BigNumberish;
-    unclaimedInterest: IPRouterStatic.TokenAmountStruct;
-    unclaimedRewards: IPRouterStatic.TokenAmountStruct[];
+    ptBalance: IPActionInfoStatic.TokenAmountStruct;
+    ytBalance: IPActionInfoStatic.TokenAmountStruct;
+    unclaimedInterest: IPActionInfoStatic.TokenAmountStruct;
+    unclaimedRewards: IPActionInfoStatic.TokenAmountStruct[];
   };
 
   export type UserPYInfoStructOutput = [
-    string,
-    string,
-    BigNumber,
-    BigNumber,
-    IPRouterStatic.TokenAmountStructOutput,
-    IPRouterStatic.TokenAmountStructOutput[]
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput[]
+  ] & {
+    ptBalance: IPActionInfoStatic.TokenAmountStructOutput;
+    ytBalance: IPActionInfoStatic.TokenAmountStructOutput;
+    unclaimedInterest: IPActionInfoStatic.TokenAmountStructOutput;
+    unclaimedRewards: IPActionInfoStatic.TokenAmountStructOutput[];
+  };
+
+  export type UserSYInfoStruct = {
+    syBalance: IPActionInfoStatic.TokenAmountStruct;
+    unclaimedRewards: IPActionInfoStatic.TokenAmountStruct[];
+  };
+
+  export type UserSYInfoStructOutput = [
+    IPActionInfoStatic.TokenAmountStructOutput,
+    IPActionInfoStatic.TokenAmountStructOutput[]
   ] & {
-    yt: string;
-    pt: string;
-    ytBalance: BigNumber;
-    ptBalance: BigNumber;
-    unclaimedInterest: IPRouterStatic.TokenAmountStructOutput;
-    unclaimedRewards: IPRouterStatic.TokenAmountStructOutput[];
+    syBalance: IPActionInfoStatic.TokenAmountStructOutput;
+    unclaimedRewards: IPActionInfoStatic.TokenAmountStructOutput[];
+  };
+}
+
+export declare namespace IPMiniDiamond {
+  export type SelectorsToFacetStruct = {
+    facet: string;
+    selectors: BytesLike[];
+  };
+
+  export type SelectorsToFacetStructOutput = [string, string[]] & {
+    facet: string;
+    selectors: string[];
   };
 }
 
 export interface IPRouterStaticInterface extends utils.Interface {
   contractName: "IPRouterStatic";
   functions: {
-    "addLiquidityDualScyAndPtStatic(address,uint256,uint256)": FunctionFragment;
-    "getMarketInfo(address)": FunctionFragment;
+    "addLiquidityDualSyAndPtStatic(address,uint256,uint256)": FunctionFragment;
+    "addLiquidityDualTokenAndPtStatic(address,address,uint256,address,uint256)": FunctionFragment;
+    "addLiquiditySinglePtStatic(address,uint256)": FunctionFragment;
+    "addLiquiditySingleSyKeepYtStatic(address,uint256)": FunctionFragment;
+    "addLiquiditySingleSyStatic(address,uint256)": FunctionFragment;
+    "addLiquiditySingleTokenKeepYtStatic(address,address,uint256,address)": FunctionFragment;
+    "addLiquiditySingleTokenStatic(address,address,uint256,address)": FunctionFragment;
+    "calcPriceImpactPY(address,int256)": FunctionFragment;
+    "calcPriceImpactPt(address,int256)": FunctionFragment;
+    "calcPriceImpactYt(address,int256)": FunctionFragment;
+    "claimOwnership()": FunctionFragment;
+    "facetAddress(bytes4)": FunctionFragment;
+    "getAmountTokenToMintSy(address,address,address,uint256)": FunctionFragment;
+    "getBulkSellerFactory()": FunctionFragment;
+    "getBulkSellerInfo(address,address,uint256,uint256)": FunctionFragment;
+    "getDefaultApproxParams()": FunctionFragment;
+    "getMarketState(address)": FunctionFragment;
+    "getOwnerAndPendingOwner()": FunctionFragment;
     "getPY(address)": FunctionFragment;
-    "getPYInfo(address)": FunctionFragment;
-    "getPendleTokenType(address)": FunctionFragment;
-    "getPtImpliedYield(address)": FunctionFragment;
+    "getTokensInOut(address)": FunctionFragment;
+    "getTradeExchangeRateExcludeFee(address,(int256,int256,int256,address,int256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "getTradeExchangeRateIncludeFee(address,int256)": FunctionFragment;
     "getUserMarketInfo(address,address)": FunctionFragment;
-    "getUserMarketPositions(address,address[])": FunctionFragment;
     "getUserPYInfo(address,address)": FunctionFragment;
-    "getUserPYPositionsByPYs(address,address[])": FunctionFragment;
-    "getUserSCYInfo(address,address)": FunctionFragment;
-    "hasPYPosition((address,address,uint256,uint256,(address,uint256),(address,uint256)[]))": FunctionFragment;
-    "pyIndex(address)": FunctionFragment;
-    "removeLiquidityDualScyAndPtStatic(address,uint256)": FunctionFragment;
-    "swapExactPtForScyStatic(address,uint256)": FunctionFragment;
-    "swapExactScyForPtStatic(address,uint256)": FunctionFragment;
-    "swapScyForExactPtStatic(address,uint256)": FunctionFragment;
+    "getUserSYInfo(address,address)": FunctionFragment;
+    "increaseLockPositionStatic(address,uint128,uint128)": FunctionFragment;
+    "mintPyFromSyStatic(address,uint256)": FunctionFragment;
+    "mintPyFromTokenStatic(address,address,uint256,address)": FunctionFragment;
+    "mintSyFromTokenStatic(address,address,uint256,address)": FunctionFragment;
+    "redeemPyToSyStatic(address,uint256)": FunctionFragment;
+    "redeemPyToTokenStatic(address,uint256,address,address)": FunctionFragment;
+    "redeemSyToTokenStatic(address,address,uint256,address)": FunctionFragment;
+    "removeLiquidityDualSyAndPtStatic(address,uint256)": FunctionFragment;
+    "removeLiquidityDualTokenAndPtStatic(address,uint256,address,address)": FunctionFragment;
+    "removeLiquiditySinglePtStatic(address,uint256)": FunctionFragment;
+    "removeLiquiditySingleSyStatic(address,uint256)": FunctionFragment;
+    "removeLiquiditySingleTokenStatic(address,uint256,address,address)": FunctionFragment;
+    "setBulkSellerFactory(address)": FunctionFragment;
+    "setDefaultApproxParams((uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "setFacetForSelectors((address,bytes4[])[])": FunctionFragment;
+    "swapExactPtForSyStatic(address,uint256)": FunctionFragment;
+    "swapExactPtForTokenStatic(address,uint256,address,address)": FunctionFragment;
+    "swapExactPtForYtStatic(address,uint256)": FunctionFragment;
+    "swapExactSyForPtStatic(address,uint256)": FunctionFragment;
+    "swapExactSyForYtStatic(address,uint256)": FunctionFragment;
+    "swapExactTokenForPtStatic(address,address,uint256,address)": FunctionFragment;
+    "swapExactTokenForYtStatic(address,address,uint256,address)": FunctionFragment;
+    "swapExactYtForPtStatic(address,uint256)": FunctionFragment;
+    "swapExactYtForSyStatic(address,uint256)": FunctionFragment;
+    "swapExactYtForTokenStatic(address,uint256,address,address)": FunctionFragment;
+    "swapPtForExactSyStatic(address,uint256)": FunctionFragment;
+    "swapSyForExactPtStatic(address,uint256)": FunctionFragment;
+    "swapSyForExactYtStatic(address,uint256)": FunctionFragment;
+    "swapYtForExactSyStatic(address,uint256)": FunctionFragment;
+    "transferOwnership(address,bool,bool)": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "addLiquidityDualScyAndPtStatic",
+    functionFragment: "addLiquidityDualSyAndPtStatic",
     values: [string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "getMarketInfo",
+    functionFragment: "addLiquidityDualTokenAndPtStatic",
+    values: [string, string, BigNumberish, string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "addLiquiditySinglePtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "addLiquiditySingleSyKeepYtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "addLiquiditySingleSyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "addLiquiditySingleTokenKeepYtStatic",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "addLiquiditySingleTokenStatic",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calcPriceImpactPY",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calcPriceImpactPt",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "calcPriceImpactYt",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "claimOwnership",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "facetAddress",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAmountTokenToMintSy",
+    values: [string, string, string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getBulkSellerFactory",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getBulkSellerInfo",
+    values: [string, string, BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getDefaultApproxParams",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getMarketState",
     values: [string]
   ): string;
+  encodeFunctionData(
+    functionFragment: "getOwnerAndPendingOwner",
+    values?: undefined
+  ): string;
   encodeFunctionData(functionFragment: "getPY", values: [string]): string;
-  encodeFunctionData(functionFragment: "getPYInfo", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "getPendleTokenType",
+    functionFragment: "getTokensInOut",
     values: [string]
   ): string;
   encodeFunctionData(
-    functionFragment: "getPtImpliedYield",
-    values: [string]
+    functionFragment: "getTradeExchangeRateExcludeFee",
+    values: [string, MarketStateStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getTradeExchangeRateIncludeFee",
+    values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "getUserMarketInfo",
     values: [string, string]
   ): string;
   encodeFunctionData(
-    functionFragment: "getUserMarketPositions",
-    values: [string, string[]]
+    functionFragment: "getUserPYInfo",
+    values: [string, string]
   ): string;
   encodeFunctionData(
-    functionFragment: "getUserPYInfo",
+    functionFragment: "getUserSYInfo",
     values: [string, string]
   ): string;
   encodeFunctionData(
-    functionFragment: "getUserPYPositionsByPYs",
-    values: [string, string[]]
+    functionFragment: "increaseLockPositionStatic",
+    values: [string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "getUserSCYInfo",
-    values: [string, string]
+    functionFragment: "mintPyFromSyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "mintPyFromTokenStatic",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "mintSyFromTokenStatic",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemPyToSyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemPyToTokenStatic",
+    values: [string, BigNumberish, string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemSyToTokenStatic",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquidityDualSyAndPtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquidityDualTokenAndPtStatic",
+    values: [string, BigNumberish, string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquiditySinglePtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquiditySingleSyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquiditySingleTokenStatic",
+    values: [string, BigNumberish, string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setBulkSellerFactory",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setDefaultApproxParams",
+    values: [ApproxParamsStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setFacetForSelectors",
+    values: [IPMiniDiamond.SelectorsToFacetStruct[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactPtForSyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactPtForTokenStatic",
+    values: [string, BigNumberish, string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactPtForYtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactSyForPtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactSyForYtStatic",
+    values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "hasPYPosition",
-    values: [IPRouterStatic.UserPYInfoStruct]
+    functionFragment: "swapExactTokenForPtStatic",
+    values: [string, string, BigNumberish, string]
   ): string;
-  encodeFunctionData(functionFragment: "pyIndex", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "removeLiquidityDualScyAndPtStatic",
+    functionFragment: "swapExactTokenForYtStatic",
+    values: [string, string, BigNumberish, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForPtStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForSyStatic",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForTokenStatic",
+    values: [string, BigNumberish, string, string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapPtForExactSyStatic",
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactPtForScyStatic",
+    functionFragment: "swapSyForExactPtStatic",
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactScyForPtStatic",
+    functionFragment: "swapSyForExactYtStatic",
     values: [string, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapScyForExactPtStatic",
+    functionFragment: "swapYtForExactSyStatic",
     values: [string, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [string, boolean, boolean]
+  ): string;
 
   decodeFunctionResult(
-    functionFragment: "addLiquidityDualScyAndPtStatic",
+    functionFragment: "addLiquidityDualSyAndPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "addLiquidityDualTokenAndPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "addLiquiditySinglePtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "addLiquiditySingleSyKeepYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "addLiquiditySingleSyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "addLiquiditySingleTokenKeepYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "addLiquiditySingleTokenStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "calcPriceImpactPY",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "calcPriceImpactPt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "calcPriceImpactYt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "claimOwnership",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "facetAddress",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getAmountTokenToMintSy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getMarketInfo",
+    functionFragment: "getBulkSellerFactory",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getBulkSellerInfo",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getDefaultApproxParams",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getMarketState",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "getOwnerAndPendingOwner",
     data: BytesLike
   ): Result;
   decodeFunctionResult(functionFragment: "getPY", data: BytesLike): Result;
-  decodeFunctionResult(functionFragment: "getPYInfo", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "getPendleTokenType",
+    functionFragment: "getTokensInOut",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getPtImpliedYield",
+    functionFragment: "getTradeExchangeRateExcludeFee",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getUserMarketInfo",
+    functionFragment: "getTradeExchangeRateIncludeFee",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getUserMarketPositions",
+    functionFragment: "getUserMarketInfo",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -253,636 +522,2250 @@ export interface IPRouterStaticInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getUserPYPositionsByPYs",
+    functionFragment: "getUserSYInfo",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "getUserSCYInfo",
+    functionFragment: "increaseLockPositionStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "hasPYPosition",
+    functionFragment: "mintPyFromSyStatic",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "pyIndex", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "removeLiquidityDualScyAndPtStatic",
+    functionFragment: "mintPyFromTokenStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactPtForScyStatic",
+    functionFragment: "mintSyFromTokenStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForPtStatic",
+    functionFragment: "redeemPyToSyStatic",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForExactPtStatic",
+    functionFragment: "redeemPyToTokenStatic",
     data: BytesLike
   ): Result;
-
-  events: {};
-}
-
-export interface IPRouterStatic extends BaseContract {
-  contractName: "IPRouterStatic";
-  connect(signerOrProvider: Signer | Provider | string): this;
-  attach(addressOrName: string): this;
-  deployed(): Promise<this>;
-
-  interface: IPRouterStaticInterface;
-
-  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: {
-    addLiquidityDualScyAndPtStatic(
-      market: string,
-      scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    getMarketInfo(
-      market: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    getPY(
-      py: string,
-      overrides?: CallOverrides
-    ): Promise<[string, string] & { pt: string; yt: string }>;
-
-    getPYInfo(
-      py: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    getPendleTokenType(
-      token: string,
-      overrides?: CallOverrides
-    ): Promise<
-      [boolean, boolean, boolean] & {
-        isPT: boolean;
-        isYT: boolean;
-        isMarket: boolean;
-      }
-    >;
-
-    getPtImpliedYield(
-      market: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    getUserMarketInfo(
-      market: string,
-      user: string,
-      overrides?: CallOverrides
-    ): Promise<
-      [IPRouterStatic.UserMarketInfoStructOutput] & {
-        userMarketInfo: IPRouterStatic.UserMarketInfoStructOutput;
-      }
-    >;
-
-    getUserMarketPositions(
+  decodeFunctionResult(
+    functionFragment: "redeemSyToTokenStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeLiquidityDualSyAndPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeLiquidityDualTokenAndPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeLiquiditySinglePtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeLiquiditySingleSyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "removeLiquiditySingleTokenStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setBulkSellerFactory",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setDefaultApproxParams",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "setFacetForSelectors",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactPtForSyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactPtForTokenStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactPtForYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactSyForPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactSyForYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactTokenForPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactTokenForYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForSyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForTokenStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapPtForExactSyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapSyForExactPtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapSyForExactYtStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapYtForExactSyStatic",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "OwnershipTransferred(address,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+
+export type OwnershipTransferredEvent = TypedEvent<
+  [string, string],
+  { previousOwner: string; newOwner: string }
+>;
+
+export type OwnershipTransferredEventFilter =
+  TypedEventFilter<OwnershipTransferredEvent>;
+
+export interface IPRouterStatic extends BaseContract {
+  contractName: "IPRouterStatic";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: IPRouterStaticInterface;
+
+  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: {
+    addLiquidityDualSyAndPtStatic(
+      market: string,
+      netSyDesired: BigNumberish,
+      netPtDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netSyUsed: BigNumber;
+        netPtUsed: BigNumber;
+      }
+    >;
+
+    addLiquidityDualTokenAndPtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenDesired: BigNumberish,
+      bulk: string,
+      netPtDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netTokenUsed: BigNumber;
+        netPtUsed: BigNumber;
+        netSyUsed: BigNumber;
+        netSyDesired: BigNumber;
+      }
+    >;
+
+    addLiquiditySinglePtStatic(
+      market: string,
+      netPtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    addLiquiditySingleSyKeepYtStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    addLiquiditySingleSyStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    addLiquiditySingleTokenKeepYtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    addLiquiditySingleTokenStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    calcPriceImpactPY(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    calcPriceImpactPt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    calcPriceImpactYt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    claimOwnership(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<[string]>;
+
+    getAmountTokenToMintSy(
+      SY: string,
+      tokenIn: string,
+      bulk: string,
+      netSyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { netTokenIn: BigNumber }>;
+
+    getBulkSellerFactory(overrides?: CallOverrides): Promise<[string]>;
+
+    getBulkSellerInfo(
+      token: string,
+      SY: string,
+      netTokenIn: BigNumberish,
+      netSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        bulk: string;
+        totalToken: BigNumber;
+        totalSy: BigNumber;
+      }
+    >;
+
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<[ApproxParamsStructOutput]>;
+
+    getMarketState(
+      market: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getOwnerAndPendingOwner(
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
+
+    getPY(
+      py: string,
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { pt: string; yt: string }>;
+
+    getTokensInOut(
+      token: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], string[]] & { tokensIn: string[]; tokensOut: string[] }
+    >;
+
+    getTradeExchangeRateExcludeFee(
+      market: string,
+      state: MarketStateStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getTradeExchangeRateIncludeFee(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getUserMarketInfo(
+      market: string,
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getUserPYInfo(
+      py: string,
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    getUserSYInfo(
+      sy: string,
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    increaseLockPositionStatic(
+      user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { newVeBalance: BigNumber }>;
+
+    mintPyFromSyStatic(
+      YT: string,
+      netSyToMint: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    mintPyFromTokenStatic(
+      YT: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    mintSyFromTokenStatic(
+      SY: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { netSyOut: BigNumber }>;
+
+    redeemPyToSyStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    redeemPyToTokenStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    redeemSyToTokenStatic(
+      SY: string,
+      tokenOut: string,
+      netSyIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { netTokenOut: BigNumber }>;
+
+    removeLiquidityDualSyAndPtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netSyOut: BigNumber; netPtOut: BigNumber }
+    >;
+
+    removeLiquidityDualTokenAndPtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        netTokenOut: BigNumber;
+        netPtOut: BigNumber;
+        netSyToRedeem: BigNumber;
+      }
+    >;
+
+    removeLiquiditySinglePtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    removeLiquiditySingleSyStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    removeLiquiditySingleTokenStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    setFacetForSelectors(
+      arr: IPMiniDiamond.SelectorsToFacetStruct[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactPtForSyStatic(
+      market: string,
+      exactPtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactPtForTokenStatic(
+      market: string,
+      exactPtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactPtForYtStatic(
+      market: string,
+      exactPtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactSyForPtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactSyForYtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactTokenForPtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactTokenForYtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactYtForPtStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactYtForSyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapExactYtForTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapPtForExactSyStatic(
+      market: string,
+      exactSyOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapSyForExactPtStatic(
+      market: string,
+      exactPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapSyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapYtForExactSyStatic(
+      market: string,
+      exactSyOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  addLiquidityDualSyAndPtStatic(
+    market: string,
+    netSyDesired: BigNumberish,
+    netPtDesired: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      netLpOut: BigNumber;
+      netSyUsed: BigNumber;
+      netPtUsed: BigNumber;
+    }
+  >;
+
+  addLiquidityDualTokenAndPtStatic(
+    market: string,
+    tokenIn: string,
+    netTokenDesired: BigNumberish,
+    bulk: string,
+    netPtDesired: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      netLpOut: BigNumber;
+      netTokenUsed: BigNumber;
+      netPtUsed: BigNumber;
+      netSyUsed: BigNumber;
+      netSyDesired: BigNumber;
+    }
+  >;
+
+  addLiquiditySinglePtStatic(
+    market: string,
+    netPtIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  addLiquiditySingleSyKeepYtStatic(
+    market: string,
+    netSyIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  addLiquiditySingleSyStatic(
+    market: string,
+    netSyIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  addLiquiditySingleTokenKeepYtStatic(
+    market: string,
+    tokenIn: string,
+    netTokenIn: BigNumberish,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  addLiquiditySingleTokenStatic(
+    market: string,
+    tokenIn: string,
+    netTokenIn: BigNumberish,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  calcPriceImpactPY(
+    market: string,
+    netPtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  calcPriceImpactPt(
+    market: string,
+    netPtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  calcPriceImpactYt(
+    market: string,
+    netPtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  claimOwnership(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  facetAddress(selector: BytesLike, overrides?: CallOverrides): Promise<string>;
+
+  getAmountTokenToMintSy(
+    SY: string,
+    tokenIn: string,
+    bulk: string,
+    netSyOut: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  getBulkSellerFactory(overrides?: CallOverrides): Promise<string>;
+
+  getBulkSellerInfo(
+    token: string,
+    SY: string,
+    netTokenIn: BigNumberish,
+    netSyIn: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [string, BigNumber, BigNumber] & {
+      bulk: string;
+      totalToken: BigNumber;
+      totalSy: BigNumber;
+    }
+  >;
+
+  getDefaultApproxParams(
+    overrides?: CallOverrides
+  ): Promise<ApproxParamsStructOutput>;
+
+  getMarketState(
+    market: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getOwnerAndPendingOwner(
+    overrides?: CallOverrides
+  ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
+
+  getPY(
+    py: string,
+    overrides?: CallOverrides
+  ): Promise<[string, string] & { pt: string; yt: string }>;
+
+  getTokensInOut(
+    token: string,
+    overrides?: CallOverrides
+  ): Promise<
+    [string[], string[]] & { tokensIn: string[]; tokensOut: string[] }
+  >;
+
+  getTradeExchangeRateExcludeFee(
+    market: string,
+    state: MarketStateStruct,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getTradeExchangeRateIncludeFee(
+    market: string,
+    netPtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getUserMarketInfo(
+    market: string,
+    user: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getUserPYInfo(
+    py: string,
+    user: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  getUserSYInfo(
+    sy: string,
+    user: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  increaseLockPositionStatic(
+    user: string,
+    additionalAmountToLock: BigNumberish,
+    newExpiry: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  mintPyFromSyStatic(
+    YT: string,
+    netSyToMint: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  mintPyFromTokenStatic(
+    YT: string,
+    tokenIn: string,
+    netTokenIn: BigNumberish,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  mintSyFromTokenStatic(
+    SY: string,
+    tokenIn: string,
+    netTokenIn: BigNumberish,
+    bulk: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  redeemPyToSyStatic(
+    YT: string,
+    netPYToRedeem: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  redeemPyToTokenStatic(
+    YT: string,
+    netPYToRedeem: BigNumberish,
+    tokenOut: string,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  redeemSyToTokenStatic(
+    SY: string,
+    tokenOut: string,
+    netSyIn: BigNumberish,
+    bulk: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  removeLiquidityDualSyAndPtStatic(
+    market: string,
+    netLpToRemove: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber] & { netSyOut: BigNumber; netPtOut: BigNumber }
+  >;
+
+  removeLiquidityDualTokenAndPtStatic(
+    market: string,
+    netLpToRemove: BigNumberish,
+    tokenOut: string,
+    bulk: string,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber] & {
+      netTokenOut: BigNumber;
+      netPtOut: BigNumber;
+      netSyToRedeem: BigNumber;
+    }
+  >;
+
+  removeLiquiditySinglePtStatic(
+    market: string,
+    netLpToRemove: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  removeLiquiditySingleSyStatic(
+    market: string,
+    netLpToRemove: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  removeLiquiditySingleTokenStatic(
+    market: string,
+    netLpToRemove: BigNumberish,
+    tokenOut: string,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  setBulkSellerFactory(
+    _bulkSellerFactory: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  setDefaultApproxParams(
+    params: ApproxParamsStruct,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  setFacetForSelectors(
+    arr: IPMiniDiamond.SelectorsToFacetStruct[],
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactPtForSyStatic(
+    market: string,
+    exactPtIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactPtForTokenStatic(
+    market: string,
+    exactPtIn: BigNumberish,
+    tokenOut: string,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactPtForYtStatic(
+    market: string,
+    exactPtIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactSyForPtStatic(
+    market: string,
+    exactSyIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactSyForYtStatic(
+    market: string,
+    exactSyIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactTokenForPtStatic(
+    market: string,
+    tokenIn: string,
+    amountTokenIn: BigNumberish,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactTokenForYtStatic(
+    market: string,
+    tokenIn: string,
+    amountTokenIn: BigNumberish,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactYtForPtStatic(
+    market: string,
+    exactYtIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactYtForSyStatic(
+    market: string,
+    exactYtIn: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapExactYtForTokenStatic(
+    market: string,
+    exactYtIn: BigNumberish,
+    tokenOut: string,
+    bulk: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapPtForExactSyStatic(
+    market: string,
+    exactSyOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapSyForExactPtStatic(
+    market: string,
+    exactPtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapSyForExactYtStatic(
+    market: string,
+    exactYtOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapYtForExactSyStatic(
+    market: string,
+    exactSyOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  transferOwnership(
+    newOwner: string,
+    direct: boolean,
+    renounce: boolean,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    addLiquidityDualSyAndPtStatic(
+      market: string,
+      netSyDesired: BigNumberish,
+      netPtDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netSyUsed: BigNumber;
+        netPtUsed: BigNumber;
+      }
+    >;
+
+    addLiquidityDualTokenAndPtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenDesired: BigNumberish,
+      bulk: string,
+      netPtDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netTokenUsed: BigNumber;
+        netPtUsed: BigNumber;
+        netSyUsed: BigNumber;
+        netSyDesired: BigNumber;
+      }
+    >;
+
+    addLiquiditySinglePtStatic(
+      market: string,
+      netPtIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netPtToSwap: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyFromSwap: BigNumber;
+      }
+    >;
+
+    addLiquiditySingleSyKeepYtStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netYtOut: BigNumber;
+        netSyToPY: BigNumber;
+      }
+    >;
+
+    addLiquiditySingleSyStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netPtFromSwap: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyToSwap: BigNumber;
+      }
+    >;
+
+    addLiquiditySingleTokenKeepYtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        netYtOut: BigNumber;
+        netSyMinted: BigNumber;
+        netSyToPY: BigNumber;
+      }
+    >;
+
+    addLiquiditySingleTokenStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        netLpOut: BigNumber;
+        netPtFromSwap: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyMinted: BigNumber;
+        netSyToSwap: BigNumber;
+      }
+    >;
+
+    calcPriceImpactPY(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    calcPriceImpactPt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    calcPriceImpactYt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    claimOwnership(overrides?: CallOverrides): Promise<void>;
+
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    getAmountTokenToMintSy(
+      SY: string,
+      tokenIn: string,
+      bulk: string,
+      netSyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getBulkSellerFactory(overrides?: CallOverrides): Promise<string>;
+
+    getBulkSellerInfo(
+      token: string,
+      SY: string,
+      netTokenIn: BigNumberish,
+      netSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [string, BigNumber, BigNumber] & {
+        bulk: string;
+        totalToken: BigNumber;
+        totalSy: BigNumber;
+      }
+    >;
+
+    getDefaultApproxParams(
+      overrides?: CallOverrides
+    ): Promise<ApproxParamsStructOutput>;
+
+    getMarketState(
+      market: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [
+        string,
+        string,
+        string,
+        BigNumber,
+        BigNumber,
+        MarketStateStructOutput
+      ] & {
+        pt: string;
+        yt: string;
+        sy: string;
+        impliedYield: BigNumber;
+        marketExchangeRateExcludeFee: BigNumber;
+        state: MarketStateStructOutput;
+      }
+    >;
+
+    getOwnerAndPendingOwner(
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
+
+    getPY(
+      py: string,
+      overrides?: CallOverrides
+    ): Promise<[string, string] & { pt: string; yt: string }>;
+
+    getTokensInOut(
+      token: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [string[], string[]] & { tokensIn: string[]; tokensOut: string[] }
+    >;
+
+    getTradeExchangeRateExcludeFee(
+      market: string,
+      state: MarketStateStruct,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getTradeExchangeRateIncludeFee(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getUserMarketInfo(
+      market: string,
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<IPActionInfoStatic.UserMarketInfoStructOutput>;
+
+    getUserPYInfo(
+      py: string,
+      user: string,
+      overrides?: CallOverrides
+    ): Promise<IPActionInfoStatic.UserPYInfoStructOutput>;
+
+    getUserSYInfo(
+      sy: string,
       user: string,
-      markets: string[],
+      overrides?: CallOverrides
+    ): Promise<IPActionInfoStatic.UserSYInfoStructOutput>;
+
+    increaseLockPositionStatic(
+      user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    mintPyFromSyStatic(
+      YT: string,
+      netSyToMint: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    mintPyFromTokenStatic(
+      YT: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    mintSyFromTokenStatic(
+      SY: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeemPyToSyStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeemPyToTokenStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeemSyToTokenStatic(
+      SY: string,
+      tokenOut: string,
+      netSyIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    removeLiquidityDualSyAndPtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netSyOut: BigNumber; netPtOut: BigNumber }
+    >;
+
+    removeLiquidityDualTokenAndPtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: CallOverrides
     ): Promise<
-      [IPRouterStatic.UserMarketInfoStructOutput[]] & {
-        userMarketPositions: IPRouterStatic.UserMarketInfoStructOutput[];
+      [BigNumber, BigNumber, BigNumber] & {
+        netTokenOut: BigNumber;
+        netPtOut: BigNumber;
+        netSyToRedeem: BigNumber;
       }
     >;
 
-    getUserPYInfo(
-      py: string,
-      user: string,
+    removeLiquiditySinglePtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [IPRouterStatic.UserPYInfoStructOutput] & {
-        userPYInfo: IPRouterStatic.UserPYInfoStructOutput;
+      [
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        netPtOut: BigNumber;
+        netPtFromSwap: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyFromBurn: BigNumber;
+        netPtFromBurn: BigNumber;
       }
     >;
 
-    getUserPYPositionsByPYs(
-      user: string,
-      pys: string[],
+    removeLiquiditySingleSyStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [IPRouterStatic.UserPYInfoStructOutput[]] & {
-        userPYPositions: IPRouterStatic.UserPYInfoStructOutput[];
+      [
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        netSyOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyFromBurn: BigNumber;
+        netPtFromBurn: BigNumber;
+        netSyFromSwap: BigNumber;
       }
     >;
 
-    getUserSCYInfo(
-      scy: string,
-      user: string,
+    removeLiquiditySingleTokenStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, IPRouterStatic.TokenAmountStructOutput[]] & {
-        balance: BigNumber;
-        rewards: IPRouterStatic.TokenAmountStructOutput[];
+      [
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        netTokenOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyOut: BigNumber;
+        netSyFromBurn: BigNumber;
+        netPtFromBurn: BigNumber;
+        netSyFromSwap: BigNumber;
       }
     >;
 
-    hasPYPosition(
-      userPYInfo: IPRouterStatic.UserPYInfoStruct,
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
       overrides?: CallOverrides
-    ): Promise<[boolean] & { hasPosition: boolean }>;
+    ): Promise<void>;
 
-    pyIndex(
-      market: string,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
+      overrides?: CallOverrides
+    ): Promise<void>;
 
-    removeLiquidityDualScyAndPtStatic(
+    setFacetForSelectors(
+      arr: IPMiniDiamond.SelectorsToFacetStruct[],
+      overrides?: CallOverrides
+    ): Promise<void>;
+
+    swapExactPtForSyStatic(
       market: string,
-      lpToRemove: BigNumberish,
+      exactPtIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyOut: BigNumber; netPtOut: BigNumber }
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netSyOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
     >;
 
-    swapExactPtForScyStatic(
+    swapExactPtForTokenStatic(
       market: string,
       exactPtIn: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+      tokenOut: string,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netTokenOut: BigNumber;
+        netSyToRedeem: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-    swapExactScyForPtStatic(
+    swapExactPtForYtStatic(
       market: string,
-      exactScyIn: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
+      exactPtIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netYtOut: BigNumber;
+        totalPtToSwap: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-    swapScyForExactPtStatic(
+    swapExactSyForPtStatic(
       market: string,
-      exactPtOut: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-  };
-
-  addLiquidityDualScyAndPtStatic(
-    market: string,
-    scyDesired: BigNumberish,
-    ptDesired: BigNumberish,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  getMarketInfo(
-    market: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  getPY(
-    py: string,
-    overrides?: CallOverrides
-  ): Promise<[string, string] & { pt: string; yt: string }>;
-
-  getPYInfo(
-    py: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  getPendleTokenType(
-    token: string,
-    overrides?: CallOverrides
-  ): Promise<
-    [boolean, boolean, boolean] & {
-      isPT: boolean;
-      isYT: boolean;
-      isMarket: boolean;
-    }
-  >;
-
-  getPtImpliedYield(
-    market: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  getUserMarketInfo(
-    market: string,
-    user: string,
-    overrides?: CallOverrides
-  ): Promise<IPRouterStatic.UserMarketInfoStructOutput>;
-
-  getUserMarketPositions(
-    user: string,
-    markets: string[],
-    overrides?: CallOverrides
-  ): Promise<IPRouterStatic.UserMarketInfoStructOutput[]>;
-
-  getUserPYInfo(
-    py: string,
-    user: string,
-    overrides?: CallOverrides
-  ): Promise<IPRouterStatic.UserPYInfoStructOutput>;
-
-  getUserPYPositionsByPYs(
-    user: string,
-    pys: string[],
-    overrides?: CallOverrides
-  ): Promise<IPRouterStatic.UserPYInfoStructOutput[]>;
-
-  getUserSCYInfo(
-    scy: string,
-    user: string,
-    overrides?: CallOverrides
-  ): Promise<
-    [BigNumber, IPRouterStatic.TokenAmountStructOutput[]] & {
-      balance: BigNumber;
-      rewards: IPRouterStatic.TokenAmountStructOutput[];
-    }
-  >;
-
-  hasPYPosition(
-    userPYInfo: IPRouterStatic.UserPYInfoStruct,
-    overrides?: CallOverrides
-  ): Promise<boolean>;
+      exactSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netPtOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-  pyIndex(
-    market: string,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+    swapExactSyForYtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netYtOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-  removeLiquidityDualScyAndPtStatic(
-    market: string,
-    lpToRemove: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<
-    [BigNumber, BigNumber] & { netScyOut: BigNumber; netPtOut: BigNumber }
-  >;
+    swapExactTokenForPtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netPtOut: BigNumber;
+        netSyMinted: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-  swapExactPtForScyStatic(
-    market: string,
-    exactPtIn: BigNumberish,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+    swapExactTokenForYtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netYtOut: BigNumber;
+        netSyMinted: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-  swapExactScyForPtStatic(
-    market: string,
-    exactScyIn: BigNumberish,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+    swapExactYtForPtStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netPtOut: BigNumber;
+        totalPtSwapped: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-  swapScyForExactPtStatic(
-    market: string,
-    exactPtOut: BigNumberish,
-    overrides?: Overrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
+    swapExactYtForSyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        netSyOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyOwedInt: BigNumber;
+        netPYToRepaySyOwedInt: BigNumber;
+        netPYToRedeemSyOutInt: BigNumber;
+      }
+    >;
 
-  callStatic: {
-    addLiquidityDualScyAndPtStatic(
+    swapExactYtForTokenStatic(
       market: string,
-      scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      exactYtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber, BigNumber] & {
-        netLpOut: BigNumber;
-        scyUsed: BigNumber;
-        ptUsed: BigNumber;
+      [
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+      ] & {
+        netTokenOut: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyOut: BigNumber;
+        netSyOwedInt: BigNumber;
+        netPYToRepaySyOwedInt: BigNumber;
+        netPYToRedeemSyOutInt: BigNumber;
       }
     >;
 
-    getMarketInfo(
+    swapPtForExactSyStatic(
       market: string,
+      exactSyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [string, string, MarketStateStructOutput, BigNumber, BigNumber] & {
-        pt: string;
-        scy: string;
-        state: MarketStateStructOutput;
-        impliedYield: BigNumber;
-        exchangeRate: BigNumber;
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netPtIn: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
       }
     >;
 
-    getPY(
-      py: string,
+    swapSyForExactPtStatic(
+      market: string,
+      exactPtOut: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<[string, string] & { pt: string; yt: string }>;
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netSyIn: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+      }
+    >;
 
-    getPYInfo(
-      py: string,
+    swapSyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber, IPRouterStatic.RewardIndexStructOutput[]] & {
-        exchangeRate: BigNumber;
-        totalSupply: BigNumber;
-        rewardIndexes: IPRouterStatic.RewardIndexStructOutput[];
+      [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netSyIn: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
+        netSyReceivedInt: BigNumber;
+        totalSyNeedInt: BigNumber;
       }
     >;
 
-    getPendleTokenType(
-      token: string,
+    swapYtForExactSyStatic(
+      market: string,
+      exactSyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [boolean, boolean, boolean] & {
-        isPT: boolean;
-        isYT: boolean;
-        isMarket: boolean;
+      [BigNumber, BigNumber, BigNumber, BigNumber] & {
+        netYtIn: BigNumber;
+        netSyFee: BigNumber;
+        priceImpact: BigNumber;
+        exchangeRateAfter: BigNumber;
       }
     >;
 
-    getPtImpliedYield(
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "OwnershipTransferred(address,address)"(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ): OwnershipTransferredEventFilter;
+    OwnershipTransferred(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ): OwnershipTransferredEventFilter;
+  };
+
+  estimateGas: {
+    addLiquidityDualSyAndPtStatic(
       market: string,
+      netSyDesired: BigNumberish,
+      netPtDesired: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    getUserMarketInfo(
+    addLiquidityDualTokenAndPtStatic(
       market: string,
-      user: string,
+      tokenIn: string,
+      netTokenDesired: BigNumberish,
+      bulk: string,
+      netPtDesired: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<IPRouterStatic.UserMarketInfoStructOutput>;
+    ): Promise<BigNumber>;
 
-    getUserMarketPositions(
-      user: string,
-      markets: string[],
+    addLiquiditySinglePtStatic(
+      market: string,
+      netPtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    addLiquiditySingleSyKeepYtStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    addLiquiditySingleSyStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    addLiquiditySingleTokenKeepYtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    addLiquiditySingleTokenStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    calcPriceImpactPY(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    calcPriceImpactPt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    calcPriceImpactYt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    claimOwnership(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getAmountTokenToMintSy(
+      SY: string,
+      tokenIn: string,
+      bulk: string,
+      netSyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getBulkSellerFactory(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getBulkSellerInfo(
+      token: string,
+      SY: string,
+      netTokenIn: BigNumberish,
+      netSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    getDefaultApproxParams(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getMarketState(
+      market: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    getOwnerAndPendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    getPY(py: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    getTokensInOut(
+      token: string,
       overrides?: CallOverrides
-    ): Promise<IPRouterStatic.UserMarketInfoStructOutput[]>;
+    ): Promise<BigNumber>;
+
+    getTradeExchangeRateExcludeFee(
+      market: string,
+      state: MarketStateStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    getTradeExchangeRateIncludeFee(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    getUserMarketInfo(
+      market: string,
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
     getUserPYInfo(
       py: string,
       user: string,
-      overrides?: CallOverrides
-    ): Promise<IPRouterStatic.UserPYInfoStructOutput>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    getUserPYPositionsByPYs(
+    getUserSYInfo(
+      sy: string,
       user: string,
-      pys: string[],
-      overrides?: CallOverrides
-    ): Promise<IPRouterStatic.UserPYInfoStructOutput[]>;
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    getUserSCYInfo(
-      scy: string,
+    increaseLockPositionStatic(
       user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<
-      [BigNumber, IPRouterStatic.TokenAmountStructOutput[]] & {
-        balance: BigNumber;
-        rewards: IPRouterStatic.TokenAmountStructOutput[];
-      }
-    >;
+    ): Promise<BigNumber>;
 
-    hasPYPosition(
-      userPYInfo: IPRouterStatic.UserPYInfoStruct,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
+    mintPyFromSyStatic(
+      YT: string,
+      netSyToMint: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    pyIndex(market: string, overrides?: CallOverrides): Promise<BigNumber>;
+    mintPyFromTokenStatic(
+      YT: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    removeLiquidityDualScyAndPtStatic(
-      market: string,
-      lpToRemove: BigNumberish,
+    mintSyFromTokenStatic(
+      SY: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
       overrides?: CallOverrides
-    ): Promise<
-      [BigNumber, BigNumber] & { netScyOut: BigNumber; netPtOut: BigNumber }
-    >;
+    ): Promise<BigNumber>;
 
-    swapExactPtForScyStatic(
-      market: string,
-      exactPtIn: BigNumberish,
+    redeemPyToSyStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    redeemPyToTokenStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    redeemSyToTokenStatic(
+      SY: string,
+      tokenOut: string,
+      netSyIn: BigNumberish,
+      bulk: string,
       overrides?: CallOverrides
-    ): Promise<
-      [BigNumber, BigNumber, BigNumber] & {
-        netScyOut: BigNumber;
-        netScyFee: BigNumber;
-        priceImpact: BigNumber;
-      }
-    >;
+    ): Promise<BigNumber>;
 
-    swapExactScyForPtStatic(
+    removeLiquidityDualSyAndPtStatic(
       market: string,
-      exactScyIn: BigNumberish,
+      netLpToRemove: BigNumberish,
       overrides?: CallOverrides
-    ): Promise<
-      [BigNumber, BigNumber, BigNumber] & {
-        netPtOut: BigNumber;
-        netScyFee: BigNumber;
-        priceImpact: BigNumber;
-      }
-    >;
+    ): Promise<BigNumber>;
 
-    swapScyForExactPtStatic(
+    removeLiquidityDualTokenAndPtStatic(
       market: string,
-      exactPtOut: BigNumberish,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: CallOverrides
-    ): Promise<
-      [BigNumber, BigNumber, BigNumber] & {
-        netScyIn: BigNumber;
-        netScyFee: BigNumber;
-        priceImpact: BigNumber;
-      }
-    >;
-  };
+    ): Promise<BigNumber>;
 
-  filters: {};
+    removeLiquiditySinglePtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-  estimateGas: {
-    addLiquidityDualScyAndPtStatic(
+    removeLiquiditySingleSyStatic(
       market: string,
-      scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      netLpToRemove: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getMarketInfo(
+    removeLiquiditySingleTokenStatic(
       market: string,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getPY(py: string, overrides?: CallOverrides): Promise<BigNumber>;
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
 
-    getPYInfo(
-      py: string,
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getPendleTokenType(
-      token: string,
-      overrides?: CallOverrides
+    setFacetForSelectors(
+      arr: IPMiniDiamond.SelectorsToFacetStruct[],
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getPtImpliedYield(
+    swapExactPtForSyStatic(
       market: string,
+      exactPtIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getUserMarketInfo(
+    swapExactPtForTokenStatic(
       market: string,
-      user: string,
-      overrides?: CallOverrides
+      exactPtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getUserMarketPositions(
-      user: string,
-      markets: string[],
-      overrides?: CallOverrides
+    swapExactPtForYtStatic(
+      market: string,
+      exactPtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getUserPYInfo(
-      py: string,
-      user: string,
-      overrides?: CallOverrides
+    swapExactSyForPtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getUserPYPositionsByPYs(
-      user: string,
-      pys: string[],
-      overrides?: CallOverrides
+    swapExactSyForYtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    getUserSCYInfo(
-      scy: string,
-      user: string,
-      overrides?: CallOverrides
+    swapExactTokenForPtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    hasPYPosition(
-      userPYInfo: IPRouterStatic.UserPYInfoStruct,
-      overrides?: CallOverrides
+    swapExactTokenForYtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    pyIndex(
+    swapExactYtForPtStatic(
       market: string,
+      exactYtIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    removeLiquidityDualScyAndPtStatic(
+    swapExactYtForSyStatic(
       market: string,
-      lpToRemove: BigNumberish,
-      overrides?: CallOverrides
+      exactYtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactPtForScyStatic(
+    swapExactYtForTokenStatic(
       market: string,
-      exactPtIn: BigNumberish,
+      exactYtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForPtStatic(
+    swapPtForExactSyStatic(
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapScyForExactPtStatic(
+    swapSyForExactPtStatic(
       market: string,
       exactPtOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
+
+    swapSyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    swapYtForExactSyStatic(
+      market: string,
+      exactSyOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    addLiquidityDualScyAndPtStatic(
+    addLiquidityDualSyAndPtStatic(
+      market: string,
+      netSyDesired: BigNumberish,
+      netPtDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    addLiquidityDualTokenAndPtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenDesired: BigNumberish,
+      bulk: string,
+      netPtDesired: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    addLiquiditySinglePtStatic(
       market: string,
-      scyDesired: BigNumberish,
-      ptDesired: BigNumberish,
+      netPtIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getMarketInfo(
+    addLiquiditySingleSyKeepYtStatic(
       market: string,
+      netSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getPY(py: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    addLiquiditySingleSyStatic(
+      market: string,
+      netSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
 
-    getPYInfo(
-      py: string,
+    addLiquiditySingleTokenKeepYtStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    addLiquiditySingleTokenStatic(
+      market: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    calcPriceImpactPY(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    calcPriceImpactPt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    calcPriceImpactYt(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    claimOwnership(
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getPendleTokenType(
+    facetAddress(
+      selector: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getAmountTokenToMintSy(
+      SY: string,
+      tokenIn: string,
+      bulk: string,
+      netSyOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getBulkSellerFactory(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getBulkSellerInfo(
       token: string,
+      SY: string,
+      netTokenIn: BigNumberish,
+      netSyIn: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    getDefaultApproxParams(
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getPtImpliedYield(
+    getMarketState(
       market: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getUserMarketInfo(
-      market: string,
-      user: string,
+    getOwnerAndPendingOwner(
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    getUserMarketPositions(
-      user: string,
-      markets: string[],
+    getPY(py: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    getTokensInOut(
+      token: string,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    getTradeExchangeRateExcludeFee(
+      market: string,
+      state: MarketStateStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getTradeExchangeRateIncludeFee(
+      market: string,
+      netPtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    getUserMarketInfo(
+      market: string,
+      user: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     getUserPYInfo(
       py: string,
       user: string,
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getUserPYPositionsByPYs(
+    getUserSYInfo(
+      sy: string,
       user: string,
-      pys: string[],
-      overrides?: CallOverrides
+      overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    getUserSCYInfo(
-      scy: string,
+    increaseLockPositionStatic(
       user: string,
+      additionalAmountToLock: BigNumberish,
+      newExpiry: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    hasPYPosition(
-      userPYInfo: IPRouterStatic.UserPYInfoStruct,
+    mintPyFromSyStatic(
+      YT: string,
+      netSyToMint: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    mintPyFromTokenStatic(
+      YT: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    mintSyFromTokenStatic(
+      SY: string,
+      tokenIn: string,
+      netTokenIn: BigNumberish,
+      bulk: string,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    pyIndex(
-      market: string,
+    redeemPyToSyStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    removeLiquidityDualScyAndPtStatic(
+    redeemPyToTokenStatic(
+      YT: string,
+      netPYToRedeem: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    redeemSyToTokenStatic(
+      SY: string,
+      tokenOut: string,
+      netSyIn: BigNumberish,
+      bulk: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    removeLiquidityDualSyAndPtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    removeLiquidityDualTokenAndPtStatic(
       market: string,
-      lpToRemove: BigNumberish,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    swapExactPtForScyStatic(
+    removeLiquiditySinglePtStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    removeLiquiditySingleSyStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    removeLiquiditySingleTokenStatic(
+      market: string,
+      netLpToRemove: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setBulkSellerFactory(
+      _bulkSellerFactory: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setDefaultApproxParams(
+      params: ApproxParamsStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    setFacetForSelectors(
+      arr: IPMiniDiamond.SelectorsToFacetStruct[],
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactPtForSyStatic(
+      market: string,
+      exactPtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactPtForTokenStatic(
+      market: string,
+      exactPtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactPtForYtStatic(
       market: string,
       exactPtIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForPtStatic(
+    swapExactSyForPtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactSyForYtStatic(
+      market: string,
+      exactSyIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactTokenForPtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactTokenForYtStatic(
+      market: string,
+      tokenIn: string,
+      amountTokenIn: BigNumberish,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactYtForPtStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactYtForSyStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapExactYtForTokenStatic(
+      market: string,
+      exactYtIn: BigNumberish,
+      tokenOut: string,
+      bulk: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapPtForExactSyStatic(
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapScyForExactPtStatic(
+    swapSyForExactPtStatic(
       market: string,
       exactPtOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
+
+    swapSyForExactYtStatic(
+      market: string,
+      exactYtOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapYtForExactSyStatic(
+      market: string,
+      exactSyOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferOwnership(
+      newOwner: string,
+      direct: boolean,
+      renounce: boolean,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
   };
 }