damm-sdk 1.4.37 → 1.4.39

package/dist/integrations/pendle/pendle.router.abi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pendle.router.abi.d.ts","sourceRoot":"","sources":["../../../src/integrations/pendle/pendle.router.abi.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBAaW"}
+{"version":3,"file":"pendle.router.abi.d.ts","sourceRoot":"","sources":["../../../src/integrations/pendle/pendle.router.abi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FH,wBAsrBW"}

package/dist/integrations/pendle/pendle.router.encoders.d.ts

@@ -0,0 +1,384 @@
+/**
+ * Pure Pendle Router V4 calldata encoders.
+ *
+ * All functions are pure: given explicit params, they return deterministic calldata
+ * via viem's `encodeFunctionData`. No network calls, no Pendle API dependency.
+ *
+ * Clean-shape guarantee (ADR-0001):
+ *   - `TokenInput.pendleSwap` is always forced to address(0).
+ *   - `TokenInput.swapData` is always `(NONE=0, address(0), 0x, false)`.
+ *   - `TokenOutput.pendleSwap` / `swapData` are forced the same way.
+ *   - `LimitOrderData` is always `(address(0), 0, [], [], 0x)`.
+ *
+ * Callers provide the user-facing subset:
+ *   - `TokenInputParams`  = `{ tokenIn, netTokenIn, tokenMintSy }`
+ *   - `TokenOutputParams` = `{ tokenOut, minTokenOut, tokenRedeemSy }`
+ *   - `ApproxParams`      = all five fields (obtained from the Pendle Hosted API)
+ *
+ * The encoder constructs the full on-chain structs internally — the caller cannot
+ * supply a non-clean `pendleSwap` or `limitRouter`.
+ *
+ * This module also contains the refactored claim encoders
+ * (`redeemDueInterestAndRewards` V1 + merkle `claim`), migrated from ethers v5
+ * to viem while keeping identical external behaviour and exports.
+ *
+ * Selectors verified against pendle-core-v2-public source + Monad/mainnet deployments
+ * (2026-06-29). PT↔YT swap functions (`swapExactPtForYt` / `swapExactYtForPt`) are
+ * intentionally absent — they do not exist on the Router V4.
+ */
+import { type Address } from "viem";
+import { type Call, type HexString, type Unwrapable } from "../../types/index.ts";
+/**
+ * On-chain binary-search hint. All five fields are required because they carry
+ * market-state information computed by the Pendle Hosted API per request.
+ */
+export type ApproxParams = Readonly<{
+    guessMin: bigint;
+    guessMax: bigint;
+    guessOffchain: bigint;
+    maxIteration: bigint;
+    eps: bigint;
+}>;
+/**
+ * User-facing TokenInput subset. The encoder forces `pendleSwap=0x0` and
+ * `swapData=CLEAN_SWAP_DATA` — the caller cannot provide a non-clean shape.
+ * Requires `tokenIn == tokenMintSy` for the aggregator-free code path.
+ */
+export type TokenInputParams = Readonly<{
+    tokenIn: Address;
+    netTokenIn: bigint;
+    tokenMintSy: Address;
+}>;
+/**
+ * User-facing TokenOutput subset. The encoder forces `pendleSwap=0x0` and
+ * `swapData=CLEAN_SWAP_DATA`.
+ * Requires `tokenOut == tokenRedeemSy` for the aggregator-free code path.
+ */
+export type TokenOutputParams = Readonly<{
+    tokenOut: Address;
+    minTokenOut: bigint;
+    tokenRedeemSy: Address;
+}>;
+export type PendleRedeemRewardsArgs = Readonly<{
+    user: Address;
+    sys: Address[];
+    yts: Address[];
+    markets: Address[];
+}>;
+export declare const pendleRedeemRewardsCalldata: ({ user, sys, yts, markets }: PendleRedeemRewardsArgs) => HexString;
+export declare const pendleRedeemRewardsTrx: ({ args, routerAddress, }: {
+    args: PendleRedeemRewardsArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type PendleMerkleClaimArgs = Readonly<{
+    receiver: Address;
+    tokens: Address[];
+    totalAccrueds: bigint[];
+    proofs: HexString[][];
+}>;
+export declare const pendleMerkleClaimCalldata: ({ receiver, tokens, totalAccrueds, proofs, }: PendleMerkleClaimArgs) => HexString;
+export declare const pendleMerkleClaimTrx: ({ args, distributorAddress, }: {
+    args: PendleMerkleClaimArgs;
+    distributorAddress: Address;
+}) => Unwrapable<Call>;
+export type MintSyFromTokenArgs = Readonly<{
+    receiver: Address;
+    sy: Address;
+    minSyOut: bigint;
+    input: TokenInputParams;
+}>;
+export declare const mintSyFromTokenCalldata: ({ receiver, sy, minSyOut, input }: MintSyFromTokenArgs) => HexString;
+export declare const mintSyFromTokenTrx: ({ args, routerAddress, }: {
+    args: MintSyFromTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RedeemSyToTokenArgs = Readonly<{
+    receiver: Address;
+    sy: Address;
+    netSyIn: bigint;
+    output: TokenOutputParams;
+}>;
+export declare const redeemSyToTokenCalldata: ({ receiver, sy, netSyIn, output }: RedeemSyToTokenArgs) => HexString;
+export declare const redeemSyToTokenTrx: ({ args, routerAddress, }: {
+    args: RedeemSyToTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type MintPyFromTokenArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    minPyOut: bigint;
+    input: TokenInputParams;
+}>;
+export declare const mintPyFromTokenCalldata: ({ receiver, yt, minPyOut, input }: MintPyFromTokenArgs) => HexString;
+export declare const mintPyFromTokenTrx: ({ args, routerAddress, }: {
+    args: MintPyFromTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RedeemPyToTokenArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    netPyIn: bigint;
+    output: TokenOutputParams;
+}>;
+export declare const redeemPyToTokenCalldata: ({ receiver, yt, netPyIn, output }: RedeemPyToTokenArgs) => HexString;
+export declare const redeemPyToTokenTrx: ({ args, routerAddress, }: {
+    args: RedeemPyToTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type MintPyFromSyArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    netSyIn: bigint;
+    minPyOut: bigint;
+}>;
+export declare const mintPyFromSyCalldata: ({ receiver, yt, netSyIn, minPyOut }: MintPyFromSyArgs) => HexString;
+export declare const mintPyFromSyTrx: ({ args, routerAddress, }: {
+    args: MintPyFromSyArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RedeemPyToSyArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    netPyIn: bigint;
+    minSyOut: bigint;
+}>;
+export declare const redeemPyToSyCalldata: ({ receiver, yt, netPyIn, minSyOut }: RedeemPyToSyArgs) => HexString;
+export declare const redeemPyToSyTrx: ({ args, routerAddress, }: {
+    args: RedeemPyToSyArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactTokenForPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minPtOut: bigint;
+    guess: ApproxParams;
+    input: TokenInputParams;
+}>;
+export declare const swapExactTokenForPtCalldata: ({ receiver, market, minPtOut, guess, input, }: SwapExactTokenForPtArgs) => HexString;
+export declare const swapExactTokenForPtTrx: ({ args, routerAddress, }: {
+    args: SwapExactTokenForPtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactSyForPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactSyIn: bigint;
+    minPtOut: bigint;
+    guess: ApproxParams;
+}>;
+export declare const swapExactSyForPtCalldata: ({ receiver, market, exactSyIn, minPtOut, guess, }: SwapExactSyForPtArgs) => HexString;
+export declare const swapExactSyForPtTrx: ({ args, routerAddress, }: {
+    args: SwapExactSyForPtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactPtForTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactPtIn: bigint;
+    output: TokenOutputParams;
+}>;
+export declare const swapExactPtForTokenCalldata: ({ receiver, market, exactPtIn, output, }: SwapExactPtForTokenArgs) => HexString;
+export declare const swapExactPtForTokenTrx: ({ args, routerAddress, }: {
+    args: SwapExactPtForTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactPtForSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactPtIn: bigint;
+    minSyOut: bigint;
+}>;
+export declare const swapExactPtForSyCalldata: ({ receiver, market, exactPtIn, minSyOut }: SwapExactPtForSyArgs) => HexString;
+export declare const swapExactPtForSyTrx: ({ args, routerAddress, }: {
+    args: SwapExactPtForSyArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactTokenForYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minYtOut: bigint;
+    guess: ApproxParams;
+    input: TokenInputParams;
+}>;
+export declare const swapExactTokenForYtCalldata: ({ receiver, market, minYtOut, guess, input, }: SwapExactTokenForYtArgs) => HexString;
+export declare const swapExactTokenForYtTrx: ({ args, routerAddress, }: {
+    args: SwapExactTokenForYtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactSyForYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactSyIn: bigint;
+    minYtOut: bigint;
+    guess: ApproxParams;
+}>;
+export declare const swapExactSyForYtCalldata: ({ receiver, market, exactSyIn, minYtOut, guess, }: SwapExactSyForYtArgs) => HexString;
+export declare const swapExactSyForYtTrx: ({ args, routerAddress, }: {
+    args: SwapExactSyForYtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactYtForTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactYtIn: bigint;
+    output: TokenOutputParams;
+}>;
+export declare const swapExactYtForTokenCalldata: ({ receiver, market, exactYtIn, output, }: SwapExactYtForTokenArgs) => HexString;
+export declare const swapExactYtForTokenTrx: ({ args, routerAddress, }: {
+    args: SwapExactYtForTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type SwapExactYtForSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactYtIn: bigint;
+    minSyOut: bigint;
+}>;
+export declare const swapExactYtForSyCalldata: ({ receiver, market, exactYtIn, minSyOut }: SwapExactYtForSyArgs) => HexString;
+export declare const swapExactYtForSyTrx: ({ args, routerAddress, }: {
+    args: SwapExactYtForSyArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquiditySingleTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minLpOut: bigint;
+    guess: ApproxParams;
+    input: TokenInputParams;
+}>;
+export declare const addLiquiditySingleTokenCalldata: ({ receiver, market, minLpOut, guess, input, }: AddLiquiditySingleTokenArgs) => HexString;
+export declare const addLiquiditySingleTokenTrx: ({ args, routerAddress, }: {
+    args: AddLiquiditySingleTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquiditySingleSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netSyIn: bigint;
+    minLpOut: bigint;
+    guess: ApproxParams;
+}>;
+export declare const addLiquiditySingleSyCalldata: ({ receiver, market, netSyIn, minLpOut, guess, }: AddLiquiditySingleSyArgs) => HexString;
+export declare const addLiquiditySingleSyTrx: ({ args, routerAddress, }: {
+    args: AddLiquiditySingleSyArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquiditySinglePtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netPtIn: bigint;
+    minLpOut: bigint;
+    guess: ApproxParams;
+}>;
+export declare const addLiquiditySinglePtCalldata: ({ receiver, market, netPtIn, minLpOut, guess, }: AddLiquiditySinglePtArgs) => HexString;
+export declare const addLiquiditySinglePtTrx: ({ args, routerAddress, }: {
+    args: AddLiquiditySinglePtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquiditySingleTokenKeepYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minLpOut: bigint;
+    minYtOut: bigint;
+    input: TokenInputParams;
+}>;
+export declare const addLiquiditySingleTokenKeepYtCalldata: ({ receiver, market, minLpOut, minYtOut, input, }: AddLiquiditySingleTokenKeepYtArgs) => HexString;
+export declare const addLiquiditySingleTokenKeepYtTrx: ({ args, routerAddress, }: {
+    args: AddLiquiditySingleTokenKeepYtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquiditySingleSyKeepYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netSyIn: bigint;
+    minLpOut: bigint;
+    minYtOut: bigint;
+}>;
+export declare const addLiquiditySingleSyKeepYtCalldata: ({ receiver, market, netSyIn, minLpOut, minYtOut, }: AddLiquiditySingleSyKeepYtArgs) => HexString;
+export declare const addLiquiditySingleSyKeepYtTrx: ({ args, routerAddress, }: {
+    args: AddLiquiditySingleSyKeepYtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquidityDualTokenAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    input: TokenInputParams;
+    netPtDesired: bigint;
+    minLpOut: bigint;
+}>;
+export declare const addLiquidityDualTokenAndPtCalldata: ({ receiver, market, input, netPtDesired, minLpOut, }: AddLiquidityDualTokenAndPtArgs) => HexString;
+export declare const addLiquidityDualTokenAndPtTrx: ({ args, routerAddress, }: {
+    args: AddLiquidityDualTokenAndPtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type AddLiquidityDualSyAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netSyDesired: bigint;
+    netPtDesired: bigint;
+    minLpOut: bigint;
+}>;
+export declare const addLiquidityDualSyAndPtCalldata: ({ receiver, market, netSyDesired, netPtDesired, minLpOut, }: AddLiquidityDualSyAndPtArgs) => HexString;
+export declare const addLiquidityDualSyAndPtTrx: ({ args, routerAddress, }: {
+    args: AddLiquidityDualSyAndPtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RemoveLiquiditySingleTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    output: TokenOutputParams;
+}>;
+export declare const removeLiquiditySingleTokenCalldata: ({ receiver, market, netLpToRemove, output, }: RemoveLiquiditySingleTokenArgs) => HexString;
+export declare const removeLiquiditySingleTokenTrx: ({ args, routerAddress, }: {
+    args: RemoveLiquiditySingleTokenArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RemoveLiquiditySingleSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    minSyOut: bigint;
+}>;
+export declare const removeLiquiditySingleSyCalldata: ({ receiver, market, netLpToRemove, minSyOut, }: RemoveLiquiditySingleSyArgs) => HexString;
+export declare const removeLiquiditySingleSyTrx: ({ args, routerAddress, }: {
+    args: RemoveLiquiditySingleSyArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RemoveLiquiditySinglePtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    minPtOut: bigint;
+    guess: ApproxParams;
+}>;
+export declare const removeLiquiditySinglePtCalldata: ({ receiver, market, netLpToRemove, minPtOut, guess, }: RemoveLiquiditySinglePtArgs) => HexString;
+export declare const removeLiquiditySinglePtTrx: ({ args, routerAddress, }: {
+    args: RemoveLiquiditySinglePtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RemoveLiquidityDualTokenAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    output: TokenOutputParams;
+    minPtOut: bigint;
+}>;
+export declare const removeLiquidityDualTokenAndPtCalldata: ({ receiver, market, netLpToRemove, output, minPtOut, }: RemoveLiquidityDualTokenAndPtArgs) => HexString;
+export declare const removeLiquidityDualTokenAndPtTrx: ({ args, routerAddress, }: {
+    args: RemoveLiquidityDualTokenAndPtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+export type RemoveLiquidityDualSyAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    minSyOut: bigint;
+    minPtOut: bigint;
+}>;
+export declare const removeLiquidityDualSyAndPtCalldata: ({ receiver, market, netLpToRemove, minSyOut, minPtOut, }: RemoveLiquidityDualSyAndPtArgs) => HexString;
+export declare const removeLiquidityDualSyAndPtTrx: ({ args, routerAddress, }: {
+    args: RemoveLiquidityDualSyAndPtArgs;
+    routerAddress: Address;
+}) => Unwrapable<Call>;
+//# sourceMappingURL=pendle.router.encoders.d.ts.map

package/dist/integrations/pendle/pendle.router.encoders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendle.router.encoders.d.ts","sourceRoot":"","sources":["../../../src/integrations/pendle/pendle.router.encoders.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -4,7 +4,7 @@
     "main": "./dist/index.cjs",
     "types": "./dist/index.d.ts",
     "type": "module",
-    "version": "1.4.37",
+    "version": "1.4.39",
     "files": [
         "dist",
         "src",
@@ -21,7 +21,8 @@
         "build": "rm -rf ./dist && bun build ./src/index.ts --outdir ./dist --entry-naming index.js --format esm --sourcemap=external && bun build ./src/index.ts --outdir ./dist --entry-naming index.cjs --format cjs --sourcemap=external && bun tsc --project tsconfig.json",
         "verify:dist": "bun run scripts/verify-dist.ts",
         "fmt": "prettier --write . && forge fmt",
-        "release": "bun run fmt && bun run build && bun run verify:dist && npm publish --tag latest"
+        "test": "bun test",
+        "release": "bun run fmt && bun run build && bun run verify:dist && bun run test && npm publish --tag latest"
     },
     "devDependencies": {
         "@types/bun": "latest",

package/src/integrations/lagoonV2/lagoon.v2.permissions.ts

@@ -79,46 +79,98 @@ function validateLagoonV2Rates(rates: LagoonV2Rates): void {
 // ---------------------------------------------------------------------------
 
 /**
- * Encodes a `settleDeposit(uint256 epoch)` call.
+ * Encodes a `settleDeposit(uint256 newTotalAssets)` call.
  * Selector: 0xd24ca58a
  * Role: Safe (Settler)
+ *
+ * The uint256 arg is the vault's NEW TOTAL ASSETS (NAV) — NOT an epoch. Verified
+ * against the deployed v0.6 impl (`settleDeposit` calls
+ * `ERC7540Lib.updateTotalAssets(_newTotalAssets)`) and the v0.5 contract; same
+ * selector and semantics on both, so this encoder is valid for v0.5 and v0.6.
+ *
+ * `epoch` is a deprecated alias for `newTotalAssets`, retained for backwards
+ * compatibility — prefer `newTotalAssets`.
  */
-export const LagoonV2SettleDepositCalldata = ({ epoch }: { epoch: bigint }): HexString => {
+export const LagoonV2SettleDepositCalldata = ({
+    newTotalAssets,
+    epoch,
+}: {
+    newTotalAssets?: bigint;
+    /** @deprecated misnomer — pass `newTotalAssets` (the NAV) instead. */
+    epoch?: bigint;
+}): HexString => {
+    const nav = newTotalAssets ?? epoch;
+    if (nav === undefined) {
+        throw new Error("LagoonV2SettleDepositCalldata: `newTotalAssets` is required");
+    }
     return encodeFunctionData({
         abi: lagoonV2VaultAbi,
         functionName: "settleDeposit",
-        args: [epoch],
+        args: [nav],
     }) as HexString;
 };
 
-export const lagoonV2SettleDepositTrx = ({ vault, epoch }: { vault: Address; epoch: bigint }): Unwrapable<Call> => {
+export const lagoonV2SettleDepositTrx = ({
+    vault,
+    newTotalAssets,
+    epoch,
+}: {
+    vault: Address;
+    newTotalAssets?: bigint;
+    /** @deprecated misnomer — pass `newTotalAssets` (the NAV) instead. */
+    epoch?: bigint;
+}): Unwrapable<Call> => {
     return createCall({
         operation: 0,
         to: vault,
         value: 0n,
-        data: LagoonV2SettleDepositCalldata({ epoch }),
+        data: LagoonV2SettleDepositCalldata({ newTotalAssets, epoch }),
     });
 };
 
 /**
- * Encodes a `settleRedeem(uint256 epoch)` call.
+ * Encodes a `settleRedeem(uint256 newTotalAssets)` call.
  * Selector: 0xa627df66
  * Role: Safe (Settler)
+ *
+ * As with settleDeposit, the uint256 arg is the NAV (verified against the deployed
+ * v0.6 impl + v0.5 contract). `epoch` is a deprecated alias kept for backwards
+ * compatibility — prefer `newTotalAssets`.
  */
-export const LagoonV2SettleRedeemCalldata = ({ epoch }: { epoch: bigint }): HexString => {
+export const LagoonV2SettleRedeemCalldata = ({
+    newTotalAssets,
+    epoch,
+}: {
+    newTotalAssets?: bigint;
+    /** @deprecated misnomer — pass `newTotalAssets` (the NAV) instead. */
+    epoch?: bigint;
+}): HexString => {
+    const nav = newTotalAssets ?? epoch;
+    if (nav === undefined) {
+        throw new Error("LagoonV2SettleRedeemCalldata: `newTotalAssets` is required");
+    }
     return encodeFunctionData({
         abi: lagoonV2VaultAbi,
         functionName: "settleRedeem",
-        args: [epoch],
+        args: [nav],
     }) as HexString;
 };
 
-export const lagoonV2SettleRedeemTrx = ({ vault, epoch }: { vault: Address; epoch: bigint }): Unwrapable<Call> => {
+export const lagoonV2SettleRedeemTrx = ({
+    vault,
+    newTotalAssets,
+    epoch,
+}: {
+    vault: Address;
+    newTotalAssets?: bigint;
+    /** @deprecated misnomer — pass `newTotalAssets` (the NAV) instead. */
+    epoch?: bigint;
+}): Unwrapable<Call> => {
     return createCall({
         operation: 0,
         to: vault,
         value: 0n,
-        data: LagoonV2SettleRedeemCalldata({ epoch }),
+        data: LagoonV2SettleRedeemCalldata({ newTotalAssets, epoch }),
     });
 };
 

package/src/integrations/lagoonV2/vault.abi.ts

@@ -53,7 +53,7 @@ export default [
         name: "settleDeposit",
         inputs: [
             {
-                name: "epoch",
+                name: "newTotalAssets",
                 type: "uint256",
                 internalType: "uint256",
             },
@@ -66,7 +66,7 @@ export default [
         name: "settleRedeem",
         inputs: [
             {
-                name: "epoch",
+                name: "newTotalAssets",
                 type: "uint256",
                 internalType: "uint256",
             },

package/src/integrations/morphoBlue/morpho.blue.ts

@@ -1,5 +1,5 @@
 import { ethers } from "ethers";
-import type { Address } from "viem";
+import { encodeAbiParameters, type Address } from "viem";
 import { type Call, type HexString, type Unwrapable, createCall } from "../../types/index.ts";
 import MorphoBlueAbi from "./morpho.blue.abi.ts";
 
@@ -304,3 +304,46 @@ export const withdrawMorphoBlueTrx = ({
         data: WithdrawMorphoBlueCalldata(args),
     });
 };
+
+// -------------------------------- MorphoBlueMarketParamsCalldata ---------------
+
+/**
+ * ABI component list for a Morpho Blue MarketParams tuple.
+ * Field order is canonical — must match the Morpho Blue solidity struct exactly:
+ * `struct MarketParams { address loanToken; address collateralToken; address oracle; address irm; uint256 lltv; }`
+ */
+const MARKET_PARAMS_ABI_COMPONENTS = [
+    {
+        type: "tuple" as const,
+        components: [
+            { name: "loanToken", type: "address" as const },
+            { name: "collateralToken", type: "address" as const },
+            { name: "oracle", type: "address" as const },
+            { name: "irm", type: "address" as const },
+            { name: "lltv", type: "uint256" as const },
+        ],
+    },
+] as const;
+
+/**
+ * Encode a `MorphoBlueMarketParams` struct as raw ABI bytes (no function selector).
+ *
+ * This produces the `data` argument passed to
+ * `forceDeallocate(adapter, data, assets, onBehalf)` on a Morpho Vault V2
+ * when the adapter is a `MorphoMarketV1Adapter`.
+ *
+ * Encoding: `abi.encode(MarketParams)` — 5 × 32-byte words, 160 bytes total:
+ *   word 0: loanToken       (address, left-padded)
+ *   word 1: collateralToken (address, left-padded)
+ *   word 2: oracle          (address, left-padded)
+ *   word 3: irm             (address, left-padded)
+ *   word 4: lltv            (uint256)
+ *
+ * Pure — no side effects, no I/O. Deterministic for identical inputs.
+ *
+ * @param marketParams - The five-field Morpho Blue market identifier.
+ * @returns 0x-prefixed hex string of 160 bytes.
+ */
+export const MorphoBlueMarketParamsCalldata = (marketParams: MorphoBlueMarketParams): HexString => {
+    return encodeAbiParameters(MARKET_PARAMS_ABI_COMPONENTS, [marketParams]) as HexString;
+};