damm-sdk 1.4.37 → 1.4.39

package/dist/index.cjs

@@ -44618,6 +44618,22 @@ __export(exports_src, {
   transferFromERC20Trx: () => transferFromERC20Trx,
   transferERC20Trx: () => transferERC20Trx,
   swapOwner: () => swapOwner,
+  swapExactYtForTokenTrx: () => swapExactYtForTokenTrx,
+  swapExactYtForTokenCalldata: () => swapExactYtForTokenCalldata,
+  swapExactYtForSyTrx: () => swapExactYtForSyTrx,
+  swapExactYtForSyCalldata: () => swapExactYtForSyCalldata,
+  swapExactTokenForYtTrx: () => swapExactTokenForYtTrx,
+  swapExactTokenForYtCalldata: () => swapExactTokenForYtCalldata,
+  swapExactTokenForPtTrx: () => swapExactTokenForPtTrx,
+  swapExactTokenForPtCalldata: () => swapExactTokenForPtCalldata,
+  swapExactSyForYtTrx: () => swapExactSyForYtTrx,
+  swapExactSyForYtCalldata: () => swapExactSyForYtCalldata,
+  swapExactSyForPtTrx: () => swapExactSyForPtTrx,
+  swapExactSyForPtCalldata: () => swapExactSyForPtCalldata,
+  swapExactPtForTokenTrx: () => swapExactPtForTokenTrx,
+  swapExactPtForTokenCalldata: () => swapExactPtForTokenCalldata,
+  swapExactPtForSyTrx: () => swapExactPtForSyTrx,
+  swapExactPtForSyCalldata: () => swapExactPtForSyCalldata,
   supplyToAaveV3Trx: () => supplyToAaveV3Trx,
   supplyMorphoBlueTrx: () => supplyMorphoBlueTrx,
   supplyCollateralMorphoBlueTrx: () => supplyCollateralMorphoBlueTrx,
@@ -44659,6 +44675,22 @@ __export(exports_src, {
   repayToLendleTrx: () => repayToLendleTrx,
   repayToAaveV3Trx: () => repayToAaveV3Trx,
   repayMorphoBlueTrx: () => repayMorphoBlueTrx,
+  removeLiquiditySingleTokenTrx: () => removeLiquiditySingleTokenTrx,
+  removeLiquiditySingleTokenCalldata: () => removeLiquiditySingleTokenCalldata,
+  removeLiquiditySingleSyTrx: () => removeLiquiditySingleSyTrx,
+  removeLiquiditySingleSyCalldata: () => removeLiquiditySingleSyCalldata,
+  removeLiquiditySinglePtTrx: () => removeLiquiditySinglePtTrx,
+  removeLiquiditySinglePtCalldata: () => removeLiquiditySinglePtCalldata,
+  removeLiquidityDualTokenAndPtTrx: () => removeLiquidityDualTokenAndPtTrx,
+  removeLiquidityDualTokenAndPtCalldata: () => removeLiquidityDualTokenAndPtCalldata,
+  removeLiquidityDualSyAndPtTrx: () => removeLiquidityDualSyAndPtTrx,
+  removeLiquidityDualSyAndPtCalldata: () => removeLiquidityDualSyAndPtCalldata,
+  redeemSyToTokenTrx: () => redeemSyToTokenTrx,
+  redeemSyToTokenCalldata: () => redeemSyToTokenCalldata,
+  redeemPyToTokenTrx: () => redeemPyToTokenTrx,
+  redeemPyToTokenCalldata: () => redeemPyToTokenCalldata,
+  redeemPyToSyTrx: () => redeemPyToSyTrx,
+  redeemPyToSyCalldata: () => redeemPyToSyCalldata,
   redeemMorphoVaultTrx: () => redeemMorphoVaultTrx,
   redeemIporFusionTrx: () => redeemIporFusionTrx,
   redeemGearboxVaultTrx: () => redeemGearboxVaultTrx,
@@ -44674,6 +44706,12 @@ __export(exports_src, {
   pauseVaultTrx: () => pauseVaultTrx,
   parseSignedQuote: () => parseSignedQuote,
   normalizeEmitterForVaaLookup: () => normalizeEmitterForVaaLookup,
+  mintSyFromTokenTrx: () => mintSyFromTokenTrx,
+  mintSyFromTokenCalldata: () => mintSyFromTokenCalldata,
+  mintPyFromTokenTrx: () => mintPyFromTokenTrx,
+  mintPyFromTokenCalldata: () => mintPyFromTokenCalldata,
+  mintPyFromSyTrx: () => mintPyFromSyTrx,
+  mintPyFromSyCalldata: () => mintPyFromSyCalldata,
   merklClaimTrx: () => merklClaimTrx,
   merklClaimCalldata: () => merklClaimCalldata,
   merklAbi: () => merkl_distributor_abi_default,
@@ -44788,6 +44826,20 @@ __export(exports_src, {
   approveERC20Trx: () => approveERC20Trx,
   addressToBytes32: () => addressToBytes32,
   addToVaultWhitelistTrx: () => addToVaultWhitelistTrx,
+  addLiquiditySingleTokenTrx: () => addLiquiditySingleTokenTrx,
+  addLiquiditySingleTokenKeepYtTrx: () => addLiquiditySingleTokenKeepYtTrx,
+  addLiquiditySingleTokenKeepYtCalldata: () => addLiquiditySingleTokenKeepYtCalldata,
+  addLiquiditySingleTokenCalldata: () => addLiquiditySingleTokenCalldata,
+  addLiquiditySingleSyTrx: () => addLiquiditySingleSyTrx,
+  addLiquiditySingleSyKeepYtTrx: () => addLiquiditySingleSyKeepYtTrx,
+  addLiquiditySingleSyKeepYtCalldata: () => addLiquiditySingleSyKeepYtCalldata,
+  addLiquiditySingleSyCalldata: () => addLiquiditySingleSyCalldata,
+  addLiquiditySinglePtTrx: () => addLiquiditySinglePtTrx,
+  addLiquiditySinglePtCalldata: () => addLiquiditySinglePtCalldata,
+  addLiquidityDualTokenAndPtTrx: () => addLiquidityDualTokenAndPtTrx,
+  addLiquidityDualTokenAndPtCalldata: () => addLiquidityDualTokenAndPtCalldata,
+  addLiquidityDualSyAndPtTrx: () => addLiquidityDualSyAndPtTrx,
+  addLiquidityDualSyAndPtCalldata: () => addLiquidityDualSyAndPtCalldata,
   ZodiacRolesAbi: () => zodiac_roles_abi_default,
   ZodiacDelayAbi: () => zodiac_delay_abi_default,
   ZERO_ADDRESS: () => ZERO_ADDRESS,
@@ -44912,6 +44964,7 @@ __export(exports_src, {
   NextTxCalldata: () => NextTxCalldata,
   MultisendBuilder: () => MultisendBuilder,
   MorphoVaultAbi: () => morpho_vault_abi_default,
+  MorphoBlueMarketParamsCalldata: () => MorphoBlueMarketParamsCalldata,
   MorphoBlueAbi: () => morpho_blue_abi_default,
   LendlePoolAbi: () => lendle_pool_abi_default,
   LagoonV2UpdateWhitelistManagerCalldata: () => LagoonV2UpdateWhitelistManagerCalldata,
@@ -55576,9 +55629,22 @@ var contractsRegistry_default = {
       withdrawManager: "0x14dd163386553b23267c097dbde868559b9bcbd2"
     },
     pendle: {
-      routerV4: "0x888888888889758f76e7103c6cbf23abbf58f946",
+      routerV4: "0x888888888889758F76e7103c6CbF23ABbF58F946",
+      routerV4ActionSwapPTV3: "0xd8D200d9A713A1c71cF1e7F694B14E5F1D948b15",
+      routerV4ActionSwapYTV3: "0x4a03Ce0a268951d04E187B1CF48075eE69266e27",
+      routerV4ActionAddRemoveLiqV3: "0x663C21103915B68e9dA797CfdF3cAb01a037D5Ff",
+      routerV4ActionMiscV3: "0x373Dba2055Ad40cb4815148bC47cd1DC16e92E44",
       routerV4ActionMisc: "0x373Dba2055Ad40cb4815148bC47cd1DC16e92E44",
-      merkleDistributor: "0x33305665f69b4642d1275f4ce81c23651674d21c"
+      limitRouter: "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+      pendleSwap: "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
+      merkleDistributor: "0x33305665f69B4642D1275f4Ce81c23651674D21C",
+      markets: {
+        usdat: "0x9aFe7a057A09cF5da748d952078C9C99938b4329",
+        usdatPT: "0x1D69402390657308C91179aa184bF992908c1e08",
+        usdatSY: "0x7a7dE491e1BE5287874904e2b7c8488249A4D0a9",
+        usdatYT: "0x076A3ea71e83Ca09319B161E40F5FB3BB943d3C6",
+        usdatUnderlying: "0x23238f20b894f29041f48D88eE91131C395Aaa71"
+      }
     }
   },
   unichain: {
@@ -55914,6 +55980,23 @@ var contractsRegistry_default = {
     },
     enso: {
       routerV2: "0xCfBAa9Cfce952Ca4F4069874fF1Df8c05e37a3c7"
+    },
+    pendle: {
+      routerV4: "0x888888888889758F76e7103c6CbF23ABbF58F946",
+      routerV4ActionSwapPTV3: "0xbb0Dd79794e58795b08b599297ec55a6Afb6AB58",
+      routerV4ActionSwapYTV3: "0x171B480B1A2ebc1acE52e46E0Bd73e7E08413ec2",
+      routerV4ActionAddRemoveLiqV3: "0x2fb6d0753602Bf397fcE38Ec8Ee3a811cA07B3FD",
+      routerV4ActionMiscV3: "0xac1700293346b0bEFC71bCB7E14Bf1c38a5c2a97",
+      limitRouter: "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
+      pendleSwap: "0xd4F480965D2347d421F1bEC7F545682E5Ec2151D",
+      merkleDistributor: "0x33305665f69B4642D1275f4Ce81c23651674D21C",
+      markets: {
+        ausd: "0x6f99CF00ee7290aE78a072Bb6910eF72D1129fE7",
+        ausdPT: "0x9FC74f8Ed616B5BaF52a170caa97d6d3898602d1",
+        ausdSY: "0xBA3d60f5000f472aef947FB8020a3E6319F9a0B7",
+        ausdYT: "0xEdDeE9C0B56248d70A9BFdD103f8bD97C35DfD89",
+        ausdUnderlying: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a"
+      }
     }
   },
   plasma: {
@@ -79473,7 +79556,7 @@ var vault_abi_default2 = [
     name: "settleDeposit",
     inputs: [
       {
-        name: "epoch",
+        name: "newTotalAssets",
         type: "uint256",
         internalType: "uint256"
       }
@@ -79486,7 +79569,7 @@ var vault_abi_default2 = [
     name: "settleRedeem",
     inputs: [
       {
-        name: "epoch",
+        name: "newTotalAssets",
         type: "uint256",
         internalType: "uint256"
       }
@@ -79888,34 +79971,56 @@ function validateLagoonV2Rates(rates) {
     throw new Error(`haircutRate ${rates.haircutRate} exceeds max 2000 bps (20%)`);
   }
 }
-var LagoonV2SettleDepositCalldata = ({ epoch }) => {
+var LagoonV2SettleDepositCalldata = ({
+  newTotalAssets,
+  epoch
+}) => {
+  const nav = newTotalAssets ?? epoch;
+  if (nav === undefined) {
+    throw new Error("LagoonV2SettleDepositCalldata: `newTotalAssets` is required");
+  }
   return encodeFunctionData({
     abi: vault_abi_default2,
     functionName: "settleDeposit",
-    args: [epoch]
+    args: [nav]
   });
 };
-var lagoonV2SettleDepositTrx = ({ vault, epoch }) => {
+var lagoonV2SettleDepositTrx = ({
+  vault,
+  newTotalAssets,
+  epoch
+}) => {
   return createCall({
     operation: 0,
     to: vault,
     value: 0n,
-    data: LagoonV2SettleDepositCalldata({ epoch })
+    data: LagoonV2SettleDepositCalldata({ newTotalAssets, epoch })
   });
 };
-var LagoonV2SettleRedeemCalldata = ({ epoch }) => {
+var LagoonV2SettleRedeemCalldata = ({
+  newTotalAssets,
+  epoch
+}) => {
+  const nav = newTotalAssets ?? epoch;
+  if (nav === undefined) {
+    throw new Error("LagoonV2SettleRedeemCalldata: `newTotalAssets` is required");
+  }
   return encodeFunctionData({
     abi: vault_abi_default2,
     functionName: "settleRedeem",
-    args: [epoch]
+    args: [nav]
   });
 };
-var lagoonV2SettleRedeemTrx = ({ vault, epoch }) => {
+var lagoonV2SettleRedeemTrx = ({
+  vault,
+  newTotalAssets,
+  epoch
+}) => {
   return createCall({
     operation: 0,
     to: vault,
     value: 0n,
-    data: LagoonV2SettleRedeemCalldata({ epoch })
+    data: LagoonV2SettleRedeemCalldata({ newTotalAssets, epoch })
   });
 };
 var LagoonV2UpdateNewTotalAssetsCalldata = ({ newTotalAssets }) => {
@@ -82860,6 +82965,21 @@ var withdrawMorphoBlueTrx = ({
     data: WithdrawMorphoBlueCalldata(args)
   });
 };
+var MARKET_PARAMS_ABI_COMPONENTS = [
+  {
+    type: "tuple",
+    components: [
+      { name: "loanToken", type: "address" },
+      { name: "collateralToken", type: "address" },
+      { name: "oracle", type: "address" },
+      { name: "irm", type: "address" },
+      { name: "lltv", type: "uint256" }
+    ]
+  }
+];
+var MorphoBlueMarketParamsCalldata = (marketParams) => {
+  return encodeAbiParameters(MARKET_PARAMS_ABI_COMPONENTS, [marketParams]);
+};
 // src/integrations/erc20/erc20.abi.ts
 var erc20_abi_default = [
   {
@@ -104636,6 +104756,84 @@ var unwrapWethTrx = ({ weth, amount }) => {
   });
 };
 // src/integrations/pendle/pendle.router.abi.ts
+var swapDataComponents = [
+  { internalType: "enum SwapType", name: "swapType", type: "uint8" },
+  { internalType: "address", name: "extRouter", type: "address" },
+  { internalType: "bytes", name: "extCalldata", type: "bytes" },
+  { internalType: "bool", name: "needScale", type: "bool" }
+];
+var tokenInputComponents = [
+  { internalType: "address", name: "tokenIn", type: "address" },
+  { internalType: "uint256", name: "netTokenIn", type: "uint256" },
+  { internalType: "address", name: "tokenMintSy", type: "address" },
+  { internalType: "address", name: "pendleSwap", type: "address" },
+  {
+    internalType: "struct SwapData",
+    name: "swapData",
+    type: "tuple",
+    components: swapDataComponents
+  }
+];
+var tokenOutputComponents = [
+  { internalType: "address", name: "tokenOut", type: "address" },
+  { internalType: "uint256", name: "minTokenOut", type: "uint256" },
+  { internalType: "address", name: "tokenRedeemSy", type: "address" },
+  { internalType: "address", name: "pendleSwap", type: "address" },
+  {
+    internalType: "struct SwapData",
+    name: "swapData",
+    type: "tuple",
+    components: swapDataComponents
+  }
+];
+var approxParamsComponents = [
+  { internalType: "uint256", name: "guessMin", type: "uint256" },
+  { internalType: "uint256", name: "guessMax", type: "uint256" },
+  { internalType: "uint256", name: "guessOffchain", type: "uint256" },
+  { internalType: "uint256", name: "maxIteration", type: "uint256" },
+  { internalType: "uint256", name: "eps", type: "uint256" }
+];
+var orderComponents = [
+  { internalType: "uint256", name: "salt", type: "uint256" },
+  { internalType: "uint256", name: "expiry", type: "uint256" },
+  { internalType: "uint256", name: "nonce", type: "uint256" },
+  { internalType: "enum OrderType", name: "orderType", type: "uint8" },
+  { internalType: "address", name: "token", type: "address" },
+  { internalType: "address", name: "YT", type: "address" },
+  { internalType: "address", name: "maker", type: "address" },
+  { internalType: "address", name: "receiver", type: "address" },
+  { internalType: "uint256", name: "makingAmount", type: "uint256" },
+  { internalType: "uint256", name: "lnImpliedRate", type: "uint256" },
+  { internalType: "uint256", name: "failSafeRate", type: "uint256" },
+  { internalType: "bytes", name: "permit", type: "bytes" }
+];
+var fillOrderParamsComponents = [
+  {
+    internalType: "struct Order",
+    name: "order",
+    type: "tuple",
+    components: orderComponents
+  },
+  { internalType: "bytes", name: "signature", type: "bytes" },
+  { internalType: "uint256", name: "makingAmount", type: "uint256" }
+];
+var limitOrderDataComponents = [
+  { internalType: "address", name: "limitRouter", type: "address" },
+  { internalType: "uint256", name: "epsSkipMarket", type: "uint256" },
+  {
+    internalType: "struct FillOrderParams[]",
+    name: "normalFills",
+    type: "tuple[]",
+    components: fillOrderParamsComponents
+  },
+  {
+    internalType: "struct FillOrderParams[]",
+    name: "flashFills",
+    type: "tuple[]",
+    components: fillOrderParamsComponents
+  },
+  { internalType: "bytes", name: "optData", type: "bytes" }
+];
 var pendle_router_abi_default = [
   {
     inputs: [
@@ -104648,6 +104846,603 @@ var pendle_router_abi_default = [
     outputs: [],
     stateMutability: "nonpayable",
     type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "SY", type: "address" },
+      { internalType: "uint256", name: "minSyOut", type: "uint256" },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      }
+    ],
+    name: "mintSyFromToken",
+    outputs: [{ internalType: "uint256", name: "netSyOut", type: "uint256" }],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "SY", type: "address" },
+      { internalType: "uint256", name: "netSyIn", type: "uint256" },
+      {
+        internalType: "struct TokenOutput",
+        name: "output",
+        type: "tuple",
+        components: tokenOutputComponents
+      }
+    ],
+    name: "redeemSyToToken",
+    outputs: [{ internalType: "uint256", name: "netTokenOut", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "YT", type: "address" },
+      { internalType: "uint256", name: "minPyOut", type: "uint256" },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      }
+    ],
+    name: "mintPyFromToken",
+    outputs: [
+      { internalType: "uint256", name: "netPyOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "YT", type: "address" },
+      { internalType: "uint256", name: "netPyIn", type: "uint256" },
+      {
+        internalType: "struct TokenOutput",
+        name: "output",
+        type: "tuple",
+        components: tokenOutputComponents
+      }
+    ],
+    name: "redeemPyToToken",
+    outputs: [
+      { internalType: "uint256", name: "netTokenOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "YT", type: "address" },
+      { internalType: "uint256", name: "netSyIn", type: "uint256" },
+      { internalType: "uint256", name: "minPyOut", type: "uint256" }
+    ],
+    name: "mintPyFromSy",
+    outputs: [{ internalType: "uint256", name: "netPyOut", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "YT", type: "address" },
+      { internalType: "uint256", name: "netPyIn", type: "uint256" },
+      { internalType: "uint256", name: "minSyOut", type: "uint256" }
+    ],
+    name: "redeemPyToSy",
+    outputs: [{ internalType: "uint256", name: "netSyOut", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "minPtOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactTokenForPt",
+    outputs: [
+      { internalType: "uint256", name: "netPtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "exactSyIn", type: "uint256" },
+      { internalType: "uint256", name: "minPtOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactSyForPt",
+    outputs: [
+      { internalType: "uint256", name: "netPtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "exactPtIn", type: "uint256" },
+      {
+        internalType: "struct TokenOutput",
+        name: "output",
+        type: "tuple",
+        components: tokenOutputComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactPtForToken",
+    outputs: [
+      { internalType: "uint256", name: "netTokenOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "exactPtIn", type: "uint256" },
+      { internalType: "uint256", name: "minSyOut", type: "uint256" },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactPtForSy",
+    outputs: [
+      { internalType: "uint256", name: "netSyOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "minYtOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactTokenForYt",
+    outputs: [
+      { internalType: "uint256", name: "netYtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "exactSyIn", type: "uint256" },
+      { internalType: "uint256", name: "minYtOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactSyForYt",
+    outputs: [
+      { internalType: "uint256", name: "netYtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "exactYtIn", type: "uint256" },
+      {
+        internalType: "struct TokenOutput",
+        name: "output",
+        type: "tuple",
+        components: tokenOutputComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactYtForToken",
+    outputs: [
+      { internalType: "uint256", name: "netTokenOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "exactYtIn", type: "uint256" },
+      { internalType: "uint256", name: "minSyOut", type: "uint256" },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "swapExactYtForSy",
+    outputs: [
+      { internalType: "uint256", name: "netSyOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "addLiquiditySingleToken",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netPtFromSwap", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netSyIn", type: "uint256" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "addLiquiditySingleSy",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netPtFromSwap", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netPtIn", type: "uint256" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "addLiquiditySinglePt",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFromSwap", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" },
+      { internalType: "uint256", name: "minYtOut", type: "uint256" },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      }
+    ],
+    name: "addLiquiditySingleTokenKeepYt",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netYtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netSyIn", type: "uint256" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" },
+      { internalType: "uint256", name: "minYtOut", type: "uint256" }
+    ],
+    name: "addLiquiditySingleSyKeepYt",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netYtOut", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      {
+        internalType: "struct TokenInput",
+        name: "input",
+        type: "tuple",
+        components: tokenInputComponents
+      },
+      { internalType: "uint256", name: "netPtDesired", type: "uint256" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" }
+    ],
+    name: "addLiquidityDualTokenAndPt",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyUsed", type: "uint256" },
+      { internalType: "uint256", name: "netPtUsed", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netSyDesired", type: "uint256" },
+      { internalType: "uint256", name: "netPtDesired", type: "uint256" },
+      { internalType: "uint256", name: "minLpOut", type: "uint256" }
+    ],
+    name: "addLiquidityDualSyAndPt",
+    outputs: [
+      { internalType: "uint256", name: "netLpOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyUsed", type: "uint256" },
+      { internalType: "uint256", name: "netPtUsed", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netLpToRemove", type: "uint256" },
+      {
+        internalType: "struct TokenOutput",
+        name: "output",
+        type: "tuple",
+        components: tokenOutputComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "removeLiquiditySingleToken",
+    outputs: [
+      { internalType: "uint256", name: "netTokenOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netLpToRemove", type: "uint256" },
+      { internalType: "uint256", name: "minSyOut", type: "uint256" },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "removeLiquiditySingleSy",
+    outputs: [
+      { internalType: "uint256", name: "netSyOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netLpToRemove", type: "uint256" },
+      { internalType: "uint256", name: "minPtOut", type: "uint256" },
+      {
+        internalType: "struct ApproxParams",
+        name: "guess",
+        type: "tuple",
+        components: approxParamsComponents
+      },
+      {
+        internalType: "struct LimitOrderData",
+        name: "limit",
+        type: "tuple",
+        components: limitOrderDataComponents
+      }
+    ],
+    name: "removeLiquiditySinglePt",
+    outputs: [
+      { internalType: "uint256", name: "netPtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netLpToRemove", type: "uint256" },
+      {
+        internalType: "struct TokenOutput",
+        name: "output",
+        type: "tuple",
+        components: tokenOutputComponents
+      },
+      { internalType: "uint256", name: "minPtOut", type: "uint256" }
+    ],
+    name: "removeLiquidityDualTokenAndPt",
+    outputs: [
+      { internalType: "uint256", name: "netTokenOut", type: "uint256" },
+      { internalType: "uint256", name: "netPtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" },
+      { internalType: "uint256", name: "netSyInterm", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "receiver", type: "address" },
+      { internalType: "address", name: "market", type: "address" },
+      { internalType: "uint256", name: "netLpToRemove", type: "uint256" },
+      { internalType: "uint256", name: "minSyOut", type: "uint256" },
+      { internalType: "uint256", name: "minPtOut", type: "uint256" }
+    ],
+    name: "removeLiquidityDualSyAndPt",
+    outputs: [
+      { internalType: "uint256", name: "netSyOut", type: "uint256" },
+      { internalType: "uint256", name: "netPtOut", type: "uint256" },
+      { internalType: "uint256", name: "netSyFee", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
   }
 ];
 // src/integrations/pendle/pendle.merkle-distributor.abi.ts
@@ -104675,47 +105470,398 @@ var pendle_merkle_distributor_abi_default = [
     type: "function"
   }
 ];
-// src/integrations/pendle/pendle.ts
-var routerInterface = new exports_ethers.utils.Interface(pendle_router_abi_default);
-var merkleDistributorInterface = new exports_ethers.utils.Interface(pendle_merkle_distributor_abi_default);
-var pendleRedeemRewardsCalldata = ({ user, sys, yts, markets }) => {
-  return routerInterface.encodeFunctionData("redeemDueInterestAndRewards", [user, sys, yts, markets]);
-};
+// src/integrations/pendle/pendle.router.encoders.ts
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var CLEAN_SWAP_DATA = {
+  swapType: 0,
+  extRouter: ZERO_ADDRESS2,
+  extCalldata: "0x",
+  needScale: false
+};
+var EMPTY_LIMIT_ORDER_DATA = {
+  limitRouter: ZERO_ADDRESS2,
+  epsSkipMarket: 0n,
+  normalFills: [],
+  flashFills: [],
+  optData: "0x"
+};
+var makeCleanTokenInput = ({ tokenIn, netTokenIn, tokenMintSy }) => ({
+  tokenIn,
+  netTokenIn,
+  tokenMintSy,
+  pendleSwap: ZERO_ADDRESS2,
+  swapData: CLEAN_SWAP_DATA
+});
+var makeCleanTokenOutput = ({ tokenOut, minTokenOut, tokenRedeemSy }) => ({
+  tokenOut,
+  minTokenOut,
+  tokenRedeemSy,
+  pendleSwap: ZERO_ADDRESS2,
+  swapData: CLEAN_SWAP_DATA
+});
+var routerTrx = (routerAddress, data) => createCall({ to: routerAddress, data, operation: 0, value: 0n });
+var distributorTrx = (distributorAddress, data) => createCall({ to: distributorAddress, data, operation: 0, value: 0n });
+var pendleRedeemRewardsCalldata = ({ user, sys, yts, markets }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "redeemDueInterestAndRewards",
+  args: [user, sys, yts, markets]
+});
 var pendleRedeemRewardsTrx = ({
   args,
   routerAddress
-}) => {
-  return createCall({
-    to: routerAddress,
-    data: pendleRedeemRewardsCalldata(args),
-    operation: 0,
-    value: 0n
-  });
-};
+}) => routerTrx(routerAddress, pendleRedeemRewardsCalldata(args));
 var pendleMerkleClaimCalldata = ({
   receiver,
   tokens,
   totalAccrueds,
   proofs
-}) => {
-  return merkleDistributorInterface.encodeFunctionData("claim", [
-    receiver,
-    tokens,
-    totalAccrueds,
-    proofs
-  ]);
-};
+}) => encodeFunctionData({
+  abi: pendle_merkle_distributor_abi_default,
+  functionName: "claim",
+  args: [receiver, tokens, totalAccrueds, proofs]
+});
 var pendleMerkleClaimTrx = ({
   args,
   distributorAddress
-}) => {
-  return createCall({
-    to: distributorAddress,
-    data: pendleMerkleClaimCalldata(args),
-    operation: 0,
-    value: 0n
-  });
-};
+}) => distributorTrx(distributorAddress, pendleMerkleClaimCalldata(args));
+var mintSyFromTokenCalldata = ({ receiver, sy, minSyOut, input }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "mintSyFromToken",
+  args: [receiver, sy, minSyOut, makeCleanTokenInput(input)]
+});
+var mintSyFromTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, mintSyFromTokenCalldata(args));
+var redeemSyToTokenCalldata = ({ receiver, sy, netSyIn, output }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "redeemSyToToken",
+  args: [receiver, sy, netSyIn, makeCleanTokenOutput(output)]
+});
+var redeemSyToTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, redeemSyToTokenCalldata(args));
+var mintPyFromTokenCalldata = ({ receiver, yt, minPyOut, input }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "mintPyFromToken",
+  args: [receiver, yt, minPyOut, makeCleanTokenInput(input)]
+});
+var mintPyFromTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, mintPyFromTokenCalldata(args));
+var redeemPyToTokenCalldata = ({ receiver, yt, netPyIn, output }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "redeemPyToToken",
+  args: [receiver, yt, netPyIn, makeCleanTokenOutput(output)]
+});
+var redeemPyToTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, redeemPyToTokenCalldata(args));
+var mintPyFromSyCalldata = ({ receiver, yt, netSyIn, minPyOut }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "mintPyFromSy",
+  args: [receiver, yt, netSyIn, minPyOut]
+});
+var mintPyFromSyTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, mintPyFromSyCalldata(args));
+var redeemPyToSyCalldata = ({ receiver, yt, netPyIn, minSyOut }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "redeemPyToSy",
+  args: [receiver, yt, netPyIn, minSyOut]
+});
+var redeemPyToSyTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, redeemPyToSyCalldata(args));
+var swapExactTokenForPtCalldata = ({
+  receiver,
+  market,
+  minPtOut,
+  guess,
+  input
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactTokenForPt",
+  args: [receiver, market, minPtOut, guess, makeCleanTokenInput(input), EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactTokenForPtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactTokenForPtCalldata(args));
+var swapExactSyForPtCalldata = ({
+  receiver,
+  market,
+  exactSyIn,
+  minPtOut,
+  guess
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactSyForPt",
+  args: [receiver, market, exactSyIn, minPtOut, guess, EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactSyForPtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactSyForPtCalldata(args));
+var swapExactPtForTokenCalldata = ({
+  receiver,
+  market,
+  exactPtIn,
+  output
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactPtForToken",
+  args: [receiver, market, exactPtIn, makeCleanTokenOutput(output), EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactPtForTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactPtForTokenCalldata(args));
+var swapExactPtForSyCalldata = ({ receiver, market, exactPtIn, minSyOut }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactPtForSy",
+  args: [receiver, market, exactPtIn, minSyOut, EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactPtForSyTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactPtForSyCalldata(args));
+var swapExactTokenForYtCalldata = ({
+  receiver,
+  market,
+  minYtOut,
+  guess,
+  input
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactTokenForYt",
+  args: [receiver, market, minYtOut, guess, makeCleanTokenInput(input), EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactTokenForYtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactTokenForYtCalldata(args));
+var swapExactSyForYtCalldata = ({
+  receiver,
+  market,
+  exactSyIn,
+  minYtOut,
+  guess
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactSyForYt",
+  args: [receiver, market, exactSyIn, minYtOut, guess, EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactSyForYtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactSyForYtCalldata(args));
+var swapExactYtForTokenCalldata = ({
+  receiver,
+  market,
+  exactYtIn,
+  output
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactYtForToken",
+  args: [receiver, market, exactYtIn, makeCleanTokenOutput(output), EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactYtForTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactYtForTokenCalldata(args));
+var swapExactYtForSyCalldata = ({ receiver, market, exactYtIn, minSyOut }) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "swapExactYtForSy",
+  args: [receiver, market, exactYtIn, minSyOut, EMPTY_LIMIT_ORDER_DATA]
+});
+var swapExactYtForSyTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, swapExactYtForSyCalldata(args));
+var addLiquiditySingleTokenCalldata = ({
+  receiver,
+  market,
+  minLpOut,
+  guess,
+  input
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquiditySingleToken",
+  args: [receiver, market, minLpOut, guess, makeCleanTokenInput(input), EMPTY_LIMIT_ORDER_DATA]
+});
+var addLiquiditySingleTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquiditySingleTokenCalldata(args));
+var addLiquiditySingleSyCalldata = ({
+  receiver,
+  market,
+  netSyIn,
+  minLpOut,
+  guess
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquiditySingleSy",
+  args: [receiver, market, netSyIn, minLpOut, guess, EMPTY_LIMIT_ORDER_DATA]
+});
+var addLiquiditySingleSyTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquiditySingleSyCalldata(args));
+var addLiquiditySinglePtCalldata = ({
+  receiver,
+  market,
+  netPtIn,
+  minLpOut,
+  guess
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquiditySinglePt",
+  args: [receiver, market, netPtIn, minLpOut, guess, EMPTY_LIMIT_ORDER_DATA]
+});
+var addLiquiditySinglePtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquiditySinglePtCalldata(args));
+var addLiquiditySingleTokenKeepYtCalldata = ({
+  receiver,
+  market,
+  minLpOut,
+  minYtOut,
+  input
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquiditySingleTokenKeepYt",
+  args: [receiver, market, minLpOut, minYtOut, makeCleanTokenInput(input)]
+});
+var addLiquiditySingleTokenKeepYtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquiditySingleTokenKeepYtCalldata(args));
+var addLiquiditySingleSyKeepYtCalldata = ({
+  receiver,
+  market,
+  netSyIn,
+  minLpOut,
+  minYtOut
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquiditySingleSyKeepYt",
+  args: [receiver, market, netSyIn, minLpOut, minYtOut]
+});
+var addLiquiditySingleSyKeepYtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquiditySingleSyKeepYtCalldata(args));
+var addLiquidityDualTokenAndPtCalldata = ({
+  receiver,
+  market,
+  input,
+  netPtDesired,
+  minLpOut
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquidityDualTokenAndPt",
+  args: [receiver, market, makeCleanTokenInput(input), netPtDesired, minLpOut]
+});
+var addLiquidityDualTokenAndPtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquidityDualTokenAndPtCalldata(args));
+var addLiquidityDualSyAndPtCalldata = ({
+  receiver,
+  market,
+  netSyDesired,
+  netPtDesired,
+  minLpOut
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "addLiquidityDualSyAndPt",
+  args: [receiver, market, netSyDesired, netPtDesired, minLpOut]
+});
+var addLiquidityDualSyAndPtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, addLiquidityDualSyAndPtCalldata(args));
+var removeLiquiditySingleTokenCalldata = ({
+  receiver,
+  market,
+  netLpToRemove,
+  output
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "removeLiquiditySingleToken",
+  args: [receiver, market, netLpToRemove, makeCleanTokenOutput(output), EMPTY_LIMIT_ORDER_DATA]
+});
+var removeLiquiditySingleTokenTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, removeLiquiditySingleTokenCalldata(args));
+var removeLiquiditySingleSyCalldata = ({
+  receiver,
+  market,
+  netLpToRemove,
+  minSyOut
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "removeLiquiditySingleSy",
+  args: [receiver, market, netLpToRemove, minSyOut, EMPTY_LIMIT_ORDER_DATA]
+});
+var removeLiquiditySingleSyTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, removeLiquiditySingleSyCalldata(args));
+var removeLiquiditySinglePtCalldata = ({
+  receiver,
+  market,
+  netLpToRemove,
+  minPtOut,
+  guess
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "removeLiquiditySinglePt",
+  args: [receiver, market, netLpToRemove, minPtOut, guess, EMPTY_LIMIT_ORDER_DATA]
+});
+var removeLiquiditySinglePtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, removeLiquiditySinglePtCalldata(args));
+var removeLiquidityDualTokenAndPtCalldata = ({
+  receiver,
+  market,
+  netLpToRemove,
+  output,
+  minPtOut
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "removeLiquidityDualTokenAndPt",
+  args: [receiver, market, netLpToRemove, makeCleanTokenOutput(output), minPtOut]
+});
+var removeLiquidityDualTokenAndPtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, removeLiquidityDualTokenAndPtCalldata(args));
+var removeLiquidityDualSyAndPtCalldata = ({
+  receiver,
+  market,
+  netLpToRemove,
+  minSyOut,
+  minPtOut
+}) => encodeFunctionData({
+  abi: pendle_router_abi_default,
+  functionName: "removeLiquidityDualSyAndPt",
+  args: [receiver, market, netLpToRemove, minSyOut, minPtOut]
+});
+var removeLiquidityDualSyAndPtTrx = ({
+  args,
+  routerAddress
+}) => routerTrx(routerAddress, removeLiquidityDualSyAndPtCalldata(args));
 // src/integrations/wormhole/wormhole.multi.ntt.abi.ts
 var wormhole_multi_ntt_abi_default = [
   {
@@ -105192,8 +106338,8 @@ var EnsoTokenType;
   EnsoTokenType2[EnsoTokenType2["Native"] = 0] = "Native";
   EnsoTokenType2[EnsoTokenType2["ERC20"] = 1] = "ERC20";
 })(EnsoTokenType ||= {});
-var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
-var isNativeToken = (token) => token.toLowerCase() === ZERO_ADDRESS2;
+var ZERO_ADDRESS3 = "0x0000000000000000000000000000000000000000";
+var isNativeToken = (token) => token.toLowerCase() === ZERO_ADDRESS3;
 var encodeEnsoToken = (token, amount) => {
   if (isNativeToken(token)) {
     return {
@@ -105361,4 +106507,4 @@ var simulateOrThrow = async (env) => {
   };
 };
 
-//# debugId=F7EC22EB720F4D9964756E2164756E21
+//# debugId=07F7E572A51A678564756E2164756E21