@pendle/core-v2 0.8.1-gamma → 0.9.2-beta

package/typechain-types/IPAllAction.ts

@@ -44,32 +44,62 @@ export type ApproxParamsStructOutput = [
   eps: BigNumber;
 };
 
+export type TokenInputStruct = {
+  tokenIn: string;
+  netTokenIn: BigNumberish;
+  tokenMintScy: string;
+  kybercall: BytesLike;
+};
+
+export type TokenInputStructOutput = [string, BigNumber, string, string] & {
+  tokenIn: string;
+  netTokenIn: BigNumber;
+  tokenMintScy: string;
+  kybercall: string;
+};
+
+export type TokenOutputStruct = {
+  tokenOut: string;
+  minTokenOut: BigNumberish;
+  tokenRedeemScy: string;
+  kybercall: BytesLike;
+};
+
+export type TokenOutputStructOutput = [string, BigNumber, string, string] & {
+  tokenOut: string;
+  minTokenOut: BigNumber;
+  tokenRedeemScy: string;
+  kybercall: string;
+};
+
 export interface IPAllActionInterface extends utils.Interface {
   contractName: "IPAllAction";
   functions: {
-    "addLiquidity(address,address,uint256,uint256,uint256)": FunctionFragment;
+    "addLiquidityDualIbTokenAndPt(address,address,uint256,uint256,uint256)": FunctionFragment;
+    "addLiquidityDualScyAndPt(address,address,uint256,uint256,uint256)": FunctionFragment;
     "addLiquiditySinglePt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "addLiquiditySingleRawToken(address,address,uint256,uint256,address[],(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "addLiquiditySingleScy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "mintPyFromRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
+    "addLiquiditySingleToken(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,bytes))": FunctionFragment;
     "mintPyFromScy(address,address,uint256,uint256)": FunctionFragment;
-    "mintScyFromRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
+    "mintPyFromToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
+    "mintScyFromToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "redeemDueInterestAndRewards(address,address[],address[],address[])": FunctionFragment;
-    "redeemPyToRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
     "redeemPyToScy(address,address,uint256,uint256)": FunctionFragment;
-    "redeemScyToRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
-    "removeLiquidity(address,address,uint256,uint256,uint256)": FunctionFragment;
+    "redeemPyToToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
+    "redeemScyToToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
+    "removeLiquidityDualIbTokenAndPt(address,address,uint256,uint256,uint256)": FunctionFragment;
+    "removeLiquidityDualScyAndPt(address,address,uint256,uint256,uint256)": FunctionFragment;
     "removeLiquiditySinglePt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "removeLiquiditySingleRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
     "removeLiquiditySingleScy(address,address,uint256,uint256)": FunctionFragment;
-    "swapExactPtForRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
+    "removeLiquiditySingleToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "swapExactPtForScy(address,address,uint256,uint256)": FunctionFragment;
-    "swapExactRawTokenForPt(address,address,uint256,uint256,address[],(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapExactRawTokenForYt(address,address,uint256,uint256,address[],(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapExactPtForToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "swapExactScyForPt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "swapExactScyForYt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapExactYtForRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
+    "swapExactTokenForPt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,bytes))": FunctionFragment;
+    "swapExactTokenForYt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,bytes))": FunctionFragment;
     "swapExactYtForScy(address,address,uint256,uint256)": FunctionFragment;
+    "swapExactYtForToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "swapPtForExactScy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "swapScyForExactPt(address,address,uint256,uint256)": FunctionFragment;
     "swapScyForExactYt(address,address,uint256,uint256)": FunctionFragment;
@@ -77,101 +107,80 @@ export interface IPAllActionInterface extends utils.Interface {
   };
 
   encodeFunctionData(
-    functionFragment: "addLiquidity",
+    functionFragment: "addLiquidityDualIbTokenAndPt",
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "addLiquiditySinglePt",
-    values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
+    functionFragment: "addLiquidityDualScyAndPt",
+    values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "addLiquiditySingleRawToken",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      string[],
-      ApproxParamsStruct
-    ]
+    functionFragment: "addLiquiditySinglePt",
+    values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "addLiquiditySingleScy",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "mintPyFromRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "addLiquiditySingleToken",
+    values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "mintPyFromScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "mintScyFromRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "mintPyFromToken",
+    values: [string, string, BigNumberish, TokenInputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemDueInterestAndRewards",
-    values: [string, string[], string[], string[]]
+    functionFragment: "mintScyFromToken",
+    values: [string, string, BigNumberish, TokenInputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemPyToRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "redeemDueInterestAndRewards",
+    values: [string, string[], string[], string[]]
   ): string;
   encodeFunctionData(
     functionFragment: "redeemPyToScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "redeemScyToRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "redeemPyToToken",
+    values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "removeLiquidity",
+    functionFragment: "redeemScyToToken",
+    values: [string, string, BigNumberish, TokenOutputStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "removeLiquidityDualIbTokenAndPt",
     values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "removeLiquiditySinglePt",
-    values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
+    functionFragment: "removeLiquidityDualScyAndPt",
+    values: [string, string, BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "removeLiquiditySingleRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "removeLiquiditySinglePt",
+    values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "removeLiquiditySingleScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactPtForRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "removeLiquiditySingleToken",
+    values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "swapExactPtForScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactRawTokenForPt",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      string[],
-      ApproxParamsStruct
-    ]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "swapExactRawTokenForYt",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      string[],
-      ApproxParamsStruct
-    ]
+    functionFragment: "swapExactPtForToken",
+    values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "swapExactScyForPt",
@@ -182,13 +191,21 @@ export interface IPAllActionInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactYtForRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "swapExactTokenForPt",
+    values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactTokenForYt",
+    values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "swapExactYtForScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForToken",
+    values: [string, string, BigNumberish, TokenOutputStruct]
+  ): string;
   encodeFunctionData(
     functionFragment: "swapPtForExactScy",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
@@ -207,15 +224,15 @@ export interface IPAllActionInterface extends utils.Interface {
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "addLiquidity",
+    functionFragment: "addLiquidityDualIbTokenAndPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "addLiquiditySinglePt",
+    functionFragment: "addLiquidityDualScyAndPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "addLiquiditySingleRawToken",
+    functionFragment: "addLiquiditySinglePt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -223,7 +240,7 @@ export interface IPAllActionInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "mintPyFromRawToken",
+    functionFragment: "addLiquiditySingleToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -231,15 +248,15 @@ export interface IPAllActionInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "mintScyFromRawToken",
+    functionFragment: "mintPyFromToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemDueInterestAndRewards",
+    functionFragment: "mintScyFromToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemPyToRawToken",
+    functionFragment: "redeemDueInterestAndRewards",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -247,39 +264,39 @@ export interface IPAllActionInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "redeemScyToRawToken",
+    functionFragment: "redeemPyToToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "removeLiquidity",
+    functionFragment: "redeemScyToToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "removeLiquiditySinglePt",
+    functionFragment: "removeLiquidityDualIbTokenAndPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "removeLiquiditySingleRawToken",
+    functionFragment: "removeLiquidityDualScyAndPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "removeLiquiditySingleScy",
+    functionFragment: "removeLiquiditySinglePt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactPtForRawToken",
+    functionFragment: "removeLiquiditySingleScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "removeLiquiditySingleToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactRawTokenForPt",
+    functionFragment: "swapExactPtForScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactRawTokenForYt",
+    functionFragment: "swapExactPtForToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -291,13 +308,21 @@ export interface IPAllActionInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactYtForRawToken",
+    functionFragment: "swapExactTokenForPt",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactTokenForYt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
     functionFragment: "swapExactYtForScy",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForToken",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "swapPtForExactScy",
     data: BytesLike
@@ -316,62 +341,73 @@ export interface IPAllActionInterface extends utils.Interface {
   ): Result;
 
   events: {
-    "AddLiquidity(address,address,address,uint256,uint256,uint256)": EventFragment;
-    "MintPyFromRawToken(address,address,address,address,uint256,uint256)": EventFragment;
+    "AddLiquidityDualIbTokenAndPt(address,address,address,uint256,uint256,uint256)": EventFragment;
+    "AddLiquidityDualScyAndPt(address,address,address,uint256,uint256,uint256)": EventFragment;
     "MintPyFromScy(address,address,address,uint256,uint256)": EventFragment;
-    "MintScyFromRawToken(address,address,address,address,uint256,uint256)": EventFragment;
-    "RedeemPyToRawToken(address,address,address,uint256,address,uint256)": EventFragment;
+    "MintPyFromToken(address,address,address,address,uint256,uint256)": EventFragment;
+    "MintScyFromToken(address,address,address,address,uint256,uint256)": EventFragment;
     "RedeemPyToScy(address,address,address,uint256,uint256)": EventFragment;
-    "RedeemScyToRawToken(address,address,address,uint256,address,uint256)": EventFragment;
-    "RemoveLiquidity(address,address,address,uint256,uint256,uint256)": EventFragment;
-    "SwapPtAndRawToken(address,address,address,address,int256,int256)": EventFragment;
+    "RedeemPyToToken(address,address,address,uint256,address,uint256)": EventFragment;
+    "RedeemScyToToken(address,address,address,uint256,address,uint256)": EventFragment;
+    "RemoveLiquidityDualIbTokenAndPt(address,address,address,uint256,uint256,uint256)": EventFragment;
+    "RemoveLiquidityDualScyAndPt(address,address,address,uint256,uint256,uint256)": EventFragment;
     "SwapPtAndScy(address,address,address,int256,int256)": EventFragment;
-    "SwapYTAndRawToken(address,address,address,int256,int256)": EventFragment;
+    "SwapPtAndToken(address,address,address,address,int256,int256)": EventFragment;
     "SwapYTAndSCY(address,address,int256,int256)": EventFragment;
+    "SwapYTAndToken(address,address,address,int256,int256)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "AddLiquidity"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "MintPyFromRawToken"): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "AddLiquidityDualIbTokenAndPt"
+  ): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "AddLiquidityDualScyAndPt"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "MintPyFromScy"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "MintScyFromRawToken"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "RedeemPyToRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "MintPyFromToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "MintScyFromToken"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "RedeemPyToScy"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "RedeemScyToRawToken"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "RemoveLiquidity"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SwapPtAndRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RedeemPyToToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "RedeemScyToToken"): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "RemoveLiquidityDualIbTokenAndPt"
+  ): EventFragment;
+  getEvent(
+    nameOrSignatureOrTopic: "RemoveLiquidityDualScyAndPt"
+  ): EventFragment;
   getEvent(nameOrSignatureOrTopic: "SwapPtAndScy"): EventFragment;
-  getEvent(nameOrSignatureOrTopic: "SwapYTAndRawToken"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SwapPtAndToken"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "SwapYTAndSCY"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SwapYTAndToken"): EventFragment;
 }
 
-export type AddLiquidityEvent = TypedEvent<
+export type AddLiquidityDualIbTokenAndPtEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber, BigNumber],
   {
     caller: string;
     market: string;
     receiver: string;
-    scyUsed: BigNumber;
+    ibTokenUsed: BigNumber;
     ptUsed: BigNumber;
     lpOut: BigNumber;
   }
 >;
 
-export type AddLiquidityEventFilter = TypedEventFilter<AddLiquidityEvent>;
+export type AddLiquidityDualIbTokenAndPtEventFilter =
+  TypedEventFilter<AddLiquidityDualIbTokenAndPtEvent>;
 
-export type MintPyFromRawTokenEvent = TypedEvent<
-  [string, string, string, string, BigNumber, BigNumber],
+export type AddLiquidityDualScyAndPtEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber, BigNumber],
   {
     caller: string;
+    market: string;
     receiver: string;
-    YT: string;
-    rawTokenIn: string;
-    netRawTokenIn: BigNumber;
-    netPyOut: BigNumber;
+    scyUsed: BigNumber;
+    ptUsed: BigNumber;
+    lpOut: BigNumber;
   }
 >;
 
-export type MintPyFromRawTokenEventFilter =
-  TypedEventFilter<MintPyFromRawTokenEvent>;
+export type AddLiquidityDualScyAndPtEventFilter =
+  TypedEventFilter<AddLiquidityDualScyAndPtEvent>;
 
 export type MintPyFromScyEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber],
@@ -386,35 +422,34 @@ export type MintPyFromScyEvent = TypedEvent<
 
 export type MintPyFromScyEventFilter = TypedEventFilter<MintPyFromScyEvent>;
 
-export type MintScyFromRawTokenEvent = TypedEvent<
+export type MintPyFromTokenEvent = TypedEvent<
   [string, string, string, string, BigNumber, BigNumber],
   {
     caller: string;
     receiver: string;
-    SCY: string;
-    rawTokenIn: string;
-    netRawTokenIn: BigNumber;
-    netScyOut: BigNumber;
+    YT: string;
+    tokenIn: string;
+    netTokenIn: BigNumber;
+    netPyOut: BigNumber;
   }
 >;
 
-export type MintScyFromRawTokenEventFilter =
-  TypedEventFilter<MintScyFromRawTokenEvent>;
+export type MintPyFromTokenEventFilter = TypedEventFilter<MintPyFromTokenEvent>;
 
-export type RedeemPyToRawTokenEvent = TypedEvent<
-  [string, string, string, BigNumber, string, BigNumber],
+export type MintScyFromTokenEvent = TypedEvent<
+  [string, string, string, string, BigNumber, BigNumber],
   {
     caller: string;
     receiver: string;
-    YT: string;
-    netPyIn: BigNumber;
-    rawTokenOut: string;
-    netRawTokenOut: BigNumber;
+    SCY: string;
+    tokenIn: string;
+    netTokenIn: BigNumber;
+    netScyOut: BigNumber;
   }
 >;
 
-export type RedeemPyToRawTokenEventFilter =
-  TypedEventFilter<RedeemPyToRawTokenEvent>;
+export type MintScyFromTokenEventFilter =
+  TypedEventFilter<MintScyFromTokenEvent>;
 
 export type RedeemPyToScyEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber],
@@ -429,22 +464,36 @@ export type RedeemPyToScyEvent = TypedEvent<
 
 export type RedeemPyToScyEventFilter = TypedEventFilter<RedeemPyToScyEvent>;
 
-export type RedeemScyToRawTokenEvent = TypedEvent<
+export type RedeemPyToTokenEvent = TypedEvent<
+  [string, string, string, BigNumber, string, BigNumber],
+  {
+    caller: string;
+    receiver: string;
+    YT: string;
+    netPyIn: BigNumber;
+    tokenOut: string;
+    netTokenOut: BigNumber;
+  }
+>;
+
+export type RedeemPyToTokenEventFilter = TypedEventFilter<RedeemPyToTokenEvent>;
+
+export type RedeemScyToTokenEvent = TypedEvent<
   [string, string, string, BigNumber, string, BigNumber],
   {
     caller: string;
     receiver: string;
     SCY: string;
     netScyIn: BigNumber;
-    rawTokenOut: string;
-    netRawTokenOut: BigNumber;
+    tokenOut: string;
+    netTokenOut: BigNumber;
   }
 >;
 
-export type RedeemScyToRawTokenEventFilter =
-  TypedEventFilter<RedeemScyToRawTokenEvent>;
+export type RedeemScyToTokenEventFilter =
+  TypedEventFilter<RedeemScyToTokenEvent>;
 
-export type RemoveLiquidityEvent = TypedEvent<
+export type RemoveLiquidityDualIbTokenAndPtEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber, BigNumber],
   {
     caller: string;
@@ -452,26 +501,27 @@ export type RemoveLiquidityEvent = TypedEvent<
     receiver: string;
     lpIn: BigNumber;
     amountPTOut: BigNumber;
-    amountSCYOut: BigNumber;
+    amountIbTokenOut: BigNumber;
   }
 >;
 
-export type RemoveLiquidityEventFilter = TypedEventFilter<RemoveLiquidityEvent>;
+export type RemoveLiquidityDualIbTokenAndPtEventFilter =
+  TypedEventFilter<RemoveLiquidityDualIbTokenAndPtEvent>;
 
-export type SwapPtAndRawTokenEvent = TypedEvent<
-  [string, string, string, string, BigNumber, BigNumber],
+export type RemoveLiquidityDualScyAndPtEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber, BigNumber],
   {
     caller: string;
     market: string;
-    rawToken: string;
     receiver: string;
-    amountPtToAccount: BigNumber;
-    amountRawTokenToAccount: BigNumber;
+    lpIn: BigNumber;
+    amountPTOut: BigNumber;
+    amountSCYOut: BigNumber;
   }
 >;
 
-export type SwapPtAndRawTokenEventFilter =
-  TypedEventFilter<SwapPtAndRawTokenEvent>;
+export type RemoveLiquidityDualScyAndPtEventFilter =
+  TypedEventFilter<RemoveLiquidityDualScyAndPtEvent>;
 
 export type SwapPtAndScyEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber],
@@ -486,19 +536,19 @@ export type SwapPtAndScyEvent = TypedEvent<
 
 export type SwapPtAndScyEventFilter = TypedEventFilter<SwapPtAndScyEvent>;
 
-export type SwapYTAndRawTokenEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber],
+export type SwapPtAndTokenEvent = TypedEvent<
+  [string, string, string, string, BigNumber, BigNumber],
   {
-    user: string;
+    caller: string;
     market: string;
-    rawToken: string;
-    ytToAccount: BigNumber;
-    rawTokenToAccount: BigNumber;
+    token: string;
+    receiver: string;
+    amountPtToAccount: BigNumber;
+    amountTokenToAccount: BigNumber;
   }
 >;
 
-export type SwapYTAndRawTokenEventFilter =
-  TypedEventFilter<SwapYTAndRawTokenEvent>;
+export type SwapPtAndTokenEventFilter = TypedEventFilter<SwapPtAndTokenEvent>;
 
 export type SwapYTAndSCYEvent = TypedEvent<
   [string, string, BigNumber, BigNumber],
@@ -512,6 +562,19 @@ export type SwapYTAndSCYEvent = TypedEvent<
 
 export type SwapYTAndSCYEventFilter = TypedEventFilter<SwapYTAndSCYEvent>;
 
+export type SwapYTAndTokenEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber],
+  {
+    user: string;
+    market: string;
+    token: string;
+    ytToAccount: BigNumber;
+    tokenToAccount: BigNumber;
+  }
+>;
+
+export type SwapYTAndTokenEventFilter = TypedEventFilter<SwapYTAndTokenEvent>;
+
 export interface IPAllAction extends BaseContract {
   contractName: "IPAllAction";
   connect(signerOrProvider: Signer | Provider | string): this;
@@ -540,7 +603,16 @@ export interface IPAllAction extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    addLiquidity(
+    addLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      ibTokenDesired: BigNumberish,
+      ptDesired: BigNumberish,
+      minLpOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    addLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
@@ -558,48 +630,45 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    addLiquiditySingleRawToken(
+    addLiquiditySingleScy(
       receiver: string,
       market: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
-      path: string[],
       guessPtReceivedFromScy: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    addLiquiditySingleScy(
+    addLiquiditySingleToken(
       receiver: string,
       market: string,
-      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
       guessPtReceivedFromScy: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    mintPyFromRawToken(
+    mintPyFromScy(
       receiver: string,
       YT: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
-      path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    mintPyFromScy(
+    mintPyFromToken(
       receiver: string,
       YT: string,
-      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    mintScyFromRawToken(
+    mintScyFromToken(
       receiver: string,
       SCY: string,
-      netRawTokenIn: BigNumberish,
       minScyOut: BigNumberish,
-      path: string[],
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -611,33 +680,40 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    redeemPyToRawToken(
+    redeemPyToScy(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    redeemPyToScy(
+    redeemPyToToken(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    redeemScyToRawToken(
+    redeemScyToToken(
       receiver: string,
       SCY: string,
       netScyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      output: TokenOutputStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    removeLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      lpToRemove: BigNumberish,
+      ibTokenMin: BigNumberish,
+      ptOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    removeLiquidity(
+    removeLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
@@ -655,92 +731,87 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    removeLiquiditySingleRawToken(
+    removeLiquiditySingleScy(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    removeLiquiditySingleScy(
+    removeLiquiditySingleToken(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactPtForRawToken(
+    swapExactPtForScy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactPtForScy(
+    swapExactPtForToken(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactRawTokenForPt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
-      path: string[],
       guessPtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactScyForPt(
+    swapExactTokenForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -779,7 +850,16 @@ export interface IPAllAction extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
-  addLiquidity(
+  addLiquidityDualIbTokenAndPt(
+    receiver: string,
+    market: string,
+    ibTokenDesired: BigNumberish,
+    ptDesired: BigNumberish,
+    minLpOut: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  addLiquidityDualScyAndPt(
     receiver: string,
     market: string,
     scyDesired: BigNumberish,
@@ -797,48 +877,45 @@ export interface IPAllAction extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  addLiquiditySingleRawToken(
+  addLiquiditySingleScy(
     receiver: string,
     market: string,
-    netRawTokenIn: BigNumberish,
+    netScyIn: BigNumberish,
     minLpOut: BigNumberish,
-    path: string[],
     guessPtReceivedFromScy: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  addLiquiditySingleScy(
+  addLiquiditySingleToken(
     receiver: string,
     market: string,
-    netScyIn: BigNumberish,
     minLpOut: BigNumberish,
     guessPtReceivedFromScy: ApproxParamsStruct,
+    input: TokenInputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  mintPyFromRawToken(
+  mintPyFromScy(
     receiver: string,
     YT: string,
-    netRawTokenIn: BigNumberish,
+    netScyIn: BigNumberish,
     minPyOut: BigNumberish,
-    path: string[],
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  mintPyFromScy(
+  mintPyFromToken(
     receiver: string,
     YT: string,
-    netScyIn: BigNumberish,
     minPyOut: BigNumberish,
+    input: TokenInputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  mintScyFromRawToken(
+  mintScyFromToken(
     receiver: string,
     SCY: string,
-    netRawTokenIn: BigNumberish,
     minScyOut: BigNumberish,
-    path: string[],
+    input: TokenInputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -850,33 +927,40 @@ export interface IPAllAction extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  redeemPyToRawToken(
+  redeemPyToScy(
     receiver: string,
     YT: string,
     netPyIn: BigNumberish,
-    minRawTokenOut: BigNumberish,
-    path: string[],
+    minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  redeemPyToScy(
+  redeemPyToToken(
     receiver: string,
     YT: string,
     netPyIn: BigNumberish,
-    minScyOut: BigNumberish,
+    output: TokenOutputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  redeemScyToRawToken(
+  redeemScyToToken(
     receiver: string,
     SCY: string,
     netScyIn: BigNumberish,
-    minRawTokenOut: BigNumberish,
-    path: string[],
+    output: TokenOutputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  removeLiquidity(
+  removeLiquidityDualIbTokenAndPt(
+    receiver: string,
+    market: string,
+    lpToRemove: BigNumberish,
+    ibTokenMin: BigNumberish,
+    ptOutMin: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  removeLiquidityDualScyAndPt(
     receiver: string,
     market: string,
     lpToRemove: BigNumberish,
@@ -894,92 +978,87 @@ export interface IPAllAction extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  removeLiquiditySingleRawToken(
+  removeLiquiditySingleScy(
     receiver: string,
     market: string,
     lpToRemove: BigNumberish,
-    minRawTokenOut: BigNumberish,
-    path: string[],
+    minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  removeLiquiditySingleScy(
+  removeLiquiditySingleToken(
     receiver: string,
     market: string,
     lpToRemove: BigNumberish,
-    minScyOut: BigNumberish,
+    output: TokenOutputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactPtForRawToken(
+  swapExactPtForScy(
     receiver: string,
     market: string,
     exactPtIn: BigNumberish,
-    minRawTokenOut: BigNumberish,
-    path: string[],
+    minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactPtForScy(
+  swapExactPtForToken(
     receiver: string,
     market: string,
     exactPtIn: BigNumberish,
-    minScyOut: BigNumberish,
+    output: TokenOutputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactRawTokenForPt(
+  swapExactScyForPt(
     receiver: string,
     market: string,
-    exactRawTokenIn: BigNumberish,
+    exactScyIn: BigNumberish,
     minPtOut: BigNumberish,
-    path: string[],
     guessPtOut: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactRawTokenForYt(
+  swapExactScyForYt(
     receiver: string,
     market: string,
-    exactRawTokenIn: BigNumberish,
+    exactScyIn: BigNumberish,
     minYtOut: BigNumberish,
-    path: string[],
     guessYtOut: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactScyForPt(
+  swapExactTokenForPt(
     receiver: string,
     market: string,
-    exactScyIn: BigNumberish,
     minPtOut: BigNumberish,
     guessPtOut: ApproxParamsStruct,
+    input: TokenInputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactScyForYt(
+  swapExactTokenForYt(
     receiver: string,
     market: string,
-    exactScyIn: BigNumberish,
     minYtOut: BigNumberish,
     guessYtOut: ApproxParamsStruct,
+    input: TokenInputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactYtForRawToken(
+  swapExactYtForScy(
     receiver: string,
     market: string,
     exactYtIn: BigNumberish,
-    minRawTokenOut: BigNumberish,
-    path: string[],
+    minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactYtForScy(
+  swapExactYtForToken(
     receiver: string,
     market: string,
-    exactYtIn: BigNumberish,
-    minScyOut: BigNumberish,
+    netYtIn: BigNumberish,
+    output: TokenOutputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -1018,7 +1097,22 @@ export interface IPAllAction extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    addLiquidity(
+    addLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      ibTokenDesired: BigNumberish,
+      ptDesired: BigNumberish,
+      minLpOut: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber, BigNumber] & {
+        netLpOut: BigNumber;
+        ibTokenUsed: BigNumber;
+        ptUsed: BigNumber;
+      }
+    >;
+
+    addLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
@@ -1042,48 +1136,45 @@ export interface IPAllAction extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    addLiquiditySingleRawToken(
+    addLiquiditySingleScy(
       receiver: string,
       market: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
-      path: string[],
       guessPtReceivedFromScy: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    addLiquiditySingleScy(
+    addLiquiditySingleToken(
       receiver: string,
       market: string,
-      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
       guessPtReceivedFromScy: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    mintPyFromRawToken(
+    mintPyFromScy(
       receiver: string,
       YT: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
-      path: string[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    mintPyFromScy(
+    mintPyFromToken(
       receiver: string,
       YT: string,
-      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
+      input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    mintScyFromRawToken(
+    mintScyFromToken(
       receiver: string,
       SCY: string,
-      netRawTokenIn: BigNumberish,
       minScyOut: BigNumberish,
-      path: string[],
+      input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -1102,33 +1193,42 @@ export interface IPAllAction extends BaseContract {
       }
     >;
 
-    redeemPyToRawToken(
+    redeemPyToScy(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    redeemPyToScy(
+    redeemPyToToken(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    redeemScyToRawToken(
+    redeemScyToToken(
       receiver: string,
       SCY: string,
       netScyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    removeLiquidity(
+    removeLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      lpToRemove: BigNumberish,
+      ibTokenMin: BigNumberish,
+      ptOutMin: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<
+      [BigNumber, BigNumber] & { netIbTokenOut: BigNumber; netPtOut: BigNumber }
+    >;
+
+    removeLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
@@ -1148,92 +1248,87 @@ export interface IPAllAction extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    removeLiquiditySingleRawToken(
+    removeLiquiditySingleScy(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    removeLiquiditySingleScy(
+    removeLiquiditySingleToken(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactPtForRawToken(
+    swapExactPtForScy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactPtForScy(
+    swapExactPtForToken(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForPt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
-      path: string[],
       guessPtOut: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactScyForPt(
+    swapExactTokenForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -1273,39 +1368,39 @@ export interface IPAllAction extends BaseContract {
   };
 
   filters: {
-    "AddLiquidity(address,address,address,uint256,uint256,uint256)"(
+    "AddLiquidityDualIbTokenAndPt(address,address,address,uint256,uint256,uint256)"(
       caller?: string | null,
       market?: string | null,
       receiver?: string | null,
-      scyUsed?: null,
+      ibTokenUsed?: null,
       ptUsed?: null,
       lpOut?: null
-    ): AddLiquidityEventFilter;
-    AddLiquidity(
+    ): AddLiquidityDualIbTokenAndPtEventFilter;
+    AddLiquidityDualIbTokenAndPt(
       caller?: string | null,
       market?: string | null,
       receiver?: string | null,
-      scyUsed?: null,
+      ibTokenUsed?: null,
       ptUsed?: null,
       lpOut?: null
-    ): AddLiquidityEventFilter;
+    ): AddLiquidityDualIbTokenAndPtEventFilter;
 
-    "MintPyFromRawToken(address,address,address,address,uint256,uint256)"(
+    "AddLiquidityDualScyAndPt(address,address,address,uint256,uint256,uint256)"(
       caller?: string | null,
+      market?: string | null,
       receiver?: string | null,
-      YT?: string | null,
-      rawTokenIn?: null,
-      netRawTokenIn?: null,
-      netPyOut?: null
-    ): MintPyFromRawTokenEventFilter;
-    MintPyFromRawToken(
+      scyUsed?: null,
+      ptUsed?: null,
+      lpOut?: null
+    ): AddLiquidityDualScyAndPtEventFilter;
+    AddLiquidityDualScyAndPt(
       caller?: string | null,
+      market?: string | null,
       receiver?: string | null,
-      YT?: string | null,
-      rawTokenIn?: null,
-      netRawTokenIn?: null,
-      netPyOut?: null
-    ): MintPyFromRawTokenEventFilter;
+      scyUsed?: null,
+      ptUsed?: null,
+      lpOut?: null
+    ): AddLiquidityDualScyAndPtEventFilter;
 
     "MintPyFromScy(address,address,address,uint256,uint256)"(
       caller?: string | null,
@@ -1322,105 +1417,122 @@ export interface IPAllAction extends BaseContract {
       netPyOut?: null
     ): MintPyFromScyEventFilter;
 
-    "MintScyFromRawToken(address,address,address,address,uint256,uint256)"(
+    "MintPyFromToken(address,address,address,address,uint256,uint256)"(
+      caller?: string | null,
+      receiver?: string | null,
+      YT?: string | null,
+      tokenIn?: null,
+      netTokenIn?: null,
+      netPyOut?: null
+    ): MintPyFromTokenEventFilter;
+    MintPyFromToken(
+      caller?: string | null,
+      receiver?: string | null,
+      YT?: string | null,
+      tokenIn?: null,
+      netTokenIn?: null,
+      netPyOut?: null
+    ): MintPyFromTokenEventFilter;
+
+    "MintScyFromToken(address,address,address,address,uint256,uint256)"(
       caller?: string | null,
       receiver?: string | null,
       SCY?: string | null,
-      rawTokenIn?: null,
-      netRawTokenIn?: null,
+      tokenIn?: null,
+      netTokenIn?: null,
       netScyOut?: null
-    ): MintScyFromRawTokenEventFilter;
-    MintScyFromRawToken(
+    ): MintScyFromTokenEventFilter;
+    MintScyFromToken(
       caller?: string | null,
       receiver?: string | null,
       SCY?: string | null,
-      rawTokenIn?: null,
-      netRawTokenIn?: null,
+      tokenIn?: null,
+      netTokenIn?: null,
       netScyOut?: null
-    ): MintScyFromRawTokenEventFilter;
+    ): MintScyFromTokenEventFilter;
 
-    "RedeemPyToRawToken(address,address,address,uint256,address,uint256)"(
+    "RedeemPyToScy(address,address,address,uint256,uint256)"(
       caller?: string | null,
       receiver?: string | null,
       YT?: string | null,
       netPyIn?: null,
-      rawTokenOut?: null,
-      netRawTokenOut?: null
-    ): RedeemPyToRawTokenEventFilter;
-    RedeemPyToRawToken(
+      netScyOut?: null
+    ): RedeemPyToScyEventFilter;
+    RedeemPyToScy(
       caller?: string | null,
       receiver?: string | null,
       YT?: string | null,
       netPyIn?: null,
-      rawTokenOut?: null,
-      netRawTokenOut?: null
-    ): RedeemPyToRawTokenEventFilter;
+      netScyOut?: null
+    ): RedeemPyToScyEventFilter;
 
-    "RedeemPyToScy(address,address,address,uint256,uint256)"(
+    "RedeemPyToToken(address,address,address,uint256,address,uint256)"(
       caller?: string | null,
       receiver?: string | null,
       YT?: string | null,
       netPyIn?: null,
-      netScyOut?: null
-    ): RedeemPyToScyEventFilter;
-    RedeemPyToScy(
+      tokenOut?: null,
+      netTokenOut?: null
+    ): RedeemPyToTokenEventFilter;
+    RedeemPyToToken(
       caller?: string | null,
       receiver?: string | null,
       YT?: string | null,
       netPyIn?: null,
-      netScyOut?: null
-    ): RedeemPyToScyEventFilter;
+      tokenOut?: null,
+      netTokenOut?: null
+    ): RedeemPyToTokenEventFilter;
 
-    "RedeemScyToRawToken(address,address,address,uint256,address,uint256)"(
+    "RedeemScyToToken(address,address,address,uint256,address,uint256)"(
       caller?: string | null,
       receiver?: string | null,
       SCY?: string | null,
       netScyIn?: null,
-      rawTokenOut?: null,
-      netRawTokenOut?: null
-    ): RedeemScyToRawTokenEventFilter;
-    RedeemScyToRawToken(
+      tokenOut?: null,
+      netTokenOut?: null
+    ): RedeemScyToTokenEventFilter;
+    RedeemScyToToken(
       caller?: string | null,
       receiver?: string | null,
       SCY?: string | null,
       netScyIn?: null,
-      rawTokenOut?: null,
-      netRawTokenOut?: null
-    ): RedeemScyToRawTokenEventFilter;
+      tokenOut?: null,
+      netTokenOut?: null
+    ): RedeemScyToTokenEventFilter;
 
-    "RemoveLiquidity(address,address,address,uint256,uint256,uint256)"(
+    "RemoveLiquidityDualIbTokenAndPt(address,address,address,uint256,uint256,uint256)"(
       caller?: string | null,
       market?: string | null,
       receiver?: null,
       lpIn?: null,
       amountPTOut?: null,
-      amountSCYOut?: null
-    ): RemoveLiquidityEventFilter;
-    RemoveLiquidity(
+      amountIbTokenOut?: null
+    ): RemoveLiquidityDualIbTokenAndPtEventFilter;
+    RemoveLiquidityDualIbTokenAndPt(
       caller?: string | null,
       market?: string | null,
       receiver?: null,
       lpIn?: null,
       amountPTOut?: null,
-      amountSCYOut?: null
-    ): RemoveLiquidityEventFilter;
+      amountIbTokenOut?: null
+    ): RemoveLiquidityDualIbTokenAndPtEventFilter;
 
-    "SwapPtAndRawToken(address,address,address,address,int256,int256)"(
+    "RemoveLiquidityDualScyAndPt(address,address,address,uint256,uint256,uint256)"(
       caller?: string | null,
       market?: string | null,
-      rawToken?: string | null,
       receiver?: null,
-      amountPtToAccount?: null,
-      amountRawTokenToAccount?: null
-    ): SwapPtAndRawTokenEventFilter;
-    SwapPtAndRawToken(
+      lpIn?: null,
+      amountPTOut?: null,
+      amountSCYOut?: null
+    ): RemoveLiquidityDualScyAndPtEventFilter;
+    RemoveLiquidityDualScyAndPt(
       caller?: string | null,
       market?: string | null,
-      rawToken?: string | null,
       receiver?: null,
-      amountPtToAccount?: null,
-      amountRawTokenToAccount?: null
-    ): SwapPtAndRawTokenEventFilter;
+      lpIn?: null,
+      amountPTOut?: null,
+      amountSCYOut?: null
+    ): RemoveLiquidityDualScyAndPtEventFilter;
 
     "SwapPtAndScy(address,address,address,int256,int256)"(
       caller?: string | null,
@@ -1437,20 +1549,22 @@ export interface IPAllAction extends BaseContract {
       amountScyToAccount?: null
     ): SwapPtAndScyEventFilter;
 
-    "SwapYTAndRawToken(address,address,address,int256,int256)"(
-      user?: string | null,
+    "SwapPtAndToken(address,address,address,address,int256,int256)"(
+      caller?: string | null,
       market?: string | null,
-      rawToken?: string | null,
-      ytToAccount?: null,
-      rawTokenToAccount?: null
-    ): SwapYTAndRawTokenEventFilter;
-    SwapYTAndRawToken(
-      user?: string | null,
+      token?: string | null,
+      receiver?: null,
+      amountPtToAccount?: null,
+      amountTokenToAccount?: null
+    ): SwapPtAndTokenEventFilter;
+    SwapPtAndToken(
+      caller?: string | null,
       market?: string | null,
-      rawToken?: string | null,
-      ytToAccount?: null,
-      rawTokenToAccount?: null
-    ): SwapYTAndRawTokenEventFilter;
+      token?: string | null,
+      receiver?: null,
+      amountPtToAccount?: null,
+      amountTokenToAccount?: null
+    ): SwapPtAndTokenEventFilter;
 
     "SwapYTAndSCY(address,address,int256,int256)"(
       user?: string | null,
@@ -1464,10 +1578,34 @@ export interface IPAllAction extends BaseContract {
       ytToAccount?: null,
       scyToAccount?: null
     ): SwapYTAndSCYEventFilter;
+
+    "SwapYTAndToken(address,address,address,int256,int256)"(
+      user?: string | null,
+      market?: string | null,
+      token?: string | null,
+      ytToAccount?: null,
+      tokenToAccount?: null
+    ): SwapYTAndTokenEventFilter;
+    SwapYTAndToken(
+      user?: string | null,
+      market?: string | null,
+      token?: string | null,
+      ytToAccount?: null,
+      tokenToAccount?: null
+    ): SwapYTAndTokenEventFilter;
   };
 
   estimateGas: {
-    addLiquidity(
+    addLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      ibTokenDesired: BigNumberish,
+      ptDesired: BigNumberish,
+      minLpOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    addLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
@@ -1485,48 +1623,45 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    addLiquiditySingleRawToken(
+    addLiquiditySingleScy(
       receiver: string,
       market: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
-      path: string[],
       guessPtReceivedFromScy: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    addLiquiditySingleScy(
+    addLiquiditySingleToken(
       receiver: string,
       market: string,
-      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
       guessPtReceivedFromScy: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    mintPyFromRawToken(
+    mintPyFromScy(
       receiver: string,
       YT: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
-      path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    mintPyFromScy(
+    mintPyFromToken(
       receiver: string,
       YT: string,
-      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    mintScyFromRawToken(
+    mintScyFromToken(
       receiver: string,
       SCY: string,
-      netRawTokenIn: BigNumberish,
       minScyOut: BigNumberish,
-      path: string[],
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -1538,33 +1673,40 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    redeemPyToRawToken(
+    redeemPyToScy(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    redeemPyToScy(
+    redeemPyToToken(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    redeemScyToRawToken(
+    redeemScyToToken(
       receiver: string,
       SCY: string,
       netScyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    removeLiquidity(
+    removeLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      lpToRemove: BigNumberish,
+      ibTokenMin: BigNumberish,
+      ptOutMin: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    removeLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
@@ -1582,92 +1724,87 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    removeLiquiditySingleRawToken(
+    removeLiquiditySingleScy(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    removeLiquiditySingleScy(
+    removeLiquiditySingleToken(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactPtForRawToken(
+    swapExactPtForScy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactPtForScy(
+    swapExactPtForToken(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForPt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
-      path: string[],
       guessPtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForPt(
+    swapExactTokenForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -1707,7 +1844,16 @@ export interface IPAllAction extends BaseContract {
   };
 
   populateTransaction: {
-    addLiquidity(
+    addLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      ibTokenDesired: BigNumberish,
+      ptDesired: BigNumberish,
+      minLpOut: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    addLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       scyDesired: BigNumberish,
@@ -1725,48 +1871,45 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    addLiquiditySingleRawToken(
+    addLiquiditySingleScy(
       receiver: string,
       market: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
-      path: string[],
       guessPtReceivedFromScy: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    addLiquiditySingleScy(
+    addLiquiditySingleToken(
       receiver: string,
       market: string,
-      netScyIn: BigNumberish,
       minLpOut: BigNumberish,
       guessPtReceivedFromScy: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    mintPyFromRawToken(
+    mintPyFromScy(
       receiver: string,
       YT: string,
-      netRawTokenIn: BigNumberish,
+      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
-      path: string[],
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    mintPyFromScy(
+    mintPyFromToken(
       receiver: string,
       YT: string,
-      netScyIn: BigNumberish,
       minPyOut: BigNumberish,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    mintScyFromRawToken(
+    mintScyFromToken(
       receiver: string,
       SCY: string,
-      netRawTokenIn: BigNumberish,
       minScyOut: BigNumberish,
-      path: string[],
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
@@ -1778,33 +1921,40 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    redeemPyToRawToken(
+    redeemPyToScy(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    redeemPyToScy(
+    redeemPyToToken(
       receiver: string,
       YT: string,
       netPyIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    redeemScyToRawToken(
+    redeemScyToToken(
       receiver: string,
       SCY: string,
       netScyIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      output: TokenOutputStruct,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    removeLiquidityDualIbTokenAndPt(
+      receiver: string,
+      market: string,
+      lpToRemove: BigNumberish,
+      ibTokenMin: BigNumberish,
+      ptOutMin: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    removeLiquidity(
+    removeLiquidityDualScyAndPt(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
@@ -1822,92 +1972,87 @@ export interface IPAllAction extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    removeLiquiditySingleRawToken(
+    removeLiquiditySingleScy(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    removeLiquiditySingleScy(
+    removeLiquiditySingleToken(
       receiver: string,
       market: string,
       lpToRemove: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactPtForRawToken(
+    swapExactPtForScy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactPtForScy(
+    swapExactPtForToken(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactRawTokenForPt(
+    swapExactScyForPt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
-      path: string[],
       guessPtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForPt(
+    swapExactTokenForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;