damm-sdk 1.4.37 → 1.4.39

package/src/integrations/pendle/pendle.router.encoders.ts

@@ -0,0 +1,977 @@
+/**
+ * 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 { encodeFunctionData, type Address } from "viem";
+import { type Call, type HexString, type Unwrapable, createCall } from "../../types/index.ts";
+import pendleRouterAbi from "./pendle.router.abi.ts";
+import pendleMerkleDistributorAbi from "./pendle.merkle-distributor.abi.ts";
+
+// =============================================================================
+// Exported parameter types (what callers provide)
+// =============================================================================
+
+/**
+ * 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;
+}>;
+
+// =============================================================================
+// Internal clean-shape constants (not exported — callers cannot override)
+// =============================================================================
+
+const ZERO_ADDRESS: Address = "0x0000000000000000000000000000000000000000";
+
+/** SwapData with aggregator disabled. swapType=NONE(0), all addresses/data zeroed. */
+const CLEAN_SWAP_DATA = {
+    swapType: 0,
+    extRouter: ZERO_ADDRESS,
+    extCalldata: "0x" as HexString,
+    needScale: false,
+} as const;
+
+/**
+ * Fully empty LimitOrderData — limitRouter=0x0, no fills, no optData.
+ * Arrays typed as `never[]` so they are assignable to any concrete FillOrderParams[].
+ */
+const EMPTY_LIMIT_ORDER_DATA = {
+    limitRouter: ZERO_ADDRESS,
+    epsSkipMarket: 0n,
+    normalFills: [] as never[],
+    flashFills: [] as never[],
+    optData: "0x" as HexString,
+};
+
+/** Expand caller-supplied TokenInputParams into the full on-chain TokenInput struct. */
+const makeCleanTokenInput = ({ tokenIn, netTokenIn, tokenMintSy }: TokenInputParams) =>
+    ({
+        tokenIn,
+        netTokenIn,
+        tokenMintSy,
+        pendleSwap: ZERO_ADDRESS,
+        swapData: CLEAN_SWAP_DATA,
+    }) as const;
+
+/** Expand caller-supplied TokenOutputParams into the full on-chain TokenOutput struct. */
+const makeCleanTokenOutput = ({ tokenOut, minTokenOut, tokenRedeemSy }: TokenOutputParams) =>
+    ({
+        tokenOut,
+        minTokenOut,
+        tokenRedeemSy,
+        pendleSwap: ZERO_ADDRESS,
+        swapData: CLEAN_SWAP_DATA,
+    }) as const;
+
+// =============================================================================
+// Shared Trx builder helper
+// =============================================================================
+
+const routerTrx = (routerAddress: Address, data: HexString): Unwrapable<Call> =>
+    createCall({ to: routerAddress, data, operation: 0, value: 0n });
+
+const distributorTrx = (distributorAddress: Address, data: HexString): Unwrapable<Call> =>
+    createCall({ to: distributorAddress, data, operation: 0, value: 0n });
+
+// =============================================================================
+// ActionMiscV3 — redeemDueInterestAndRewards (V1) — on-chain claim
+// Refactored from ethers v5 → viem (behaviour unchanged).
+// =============================================================================
+
+export type PendleRedeemRewardsArgs = Readonly<{
+    user: Address;
+    sys: Address[];
+    yts: Address[];
+    markets: Address[];
+}>;
+
+export const pendleRedeemRewardsCalldata = ({ user, sys, yts, markets }: PendleRedeemRewardsArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "redeemDueInterestAndRewards",
+        args: [user, sys, yts, markets],
+    });
+
+export const pendleRedeemRewardsTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: PendleRedeemRewardsArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, pendleRedeemRewardsCalldata(args));
+
+// =============================================================================
+// MerkleDistributor — claim (off-chain merkle rewards)
+// Refactored from ethers v5 → viem (behaviour unchanged).
+// =============================================================================
+
+export type PendleMerkleClaimArgs = Readonly<{
+    receiver: Address;
+    tokens: Address[];
+    totalAccrueds: bigint[];
+    proofs: HexString[][];
+}>;
+
+export const pendleMerkleClaimCalldata = ({
+    receiver,
+    tokens,
+    totalAccrueds,
+    proofs,
+}: PendleMerkleClaimArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleMerkleDistributorAbi,
+        functionName: "claim",
+        args: [receiver, tokens, totalAccrueds, proofs],
+    });
+
+export const pendleMerkleClaimTrx = ({
+    args,
+    distributorAddress,
+}: {
+    args: PendleMerkleClaimArgs;
+    distributorAddress: Address;
+}): Unwrapable<Call> => distributorTrx(distributorAddress, pendleMerkleClaimCalldata(args));
+
+// =============================================================================
+// ActionMiscV3 — SY wrap/unwrap
+// =============================================================================
+
+// ---- mintSyFromToken -------------------------------------------------------
+// Wraps a SY-native token into SY. Clean shape: pendleSwap=0, swapType=NONE.
+
+export type MintSyFromTokenArgs = Readonly<{
+    receiver: Address;
+    sy: Address;
+    minSyOut: bigint;
+    input: TokenInputParams;
+}>;
+
+export const mintSyFromTokenCalldata = ({ receiver, sy, minSyOut, input }: MintSyFromTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "mintSyFromToken",
+        args: [receiver, sy, minSyOut, makeCleanTokenInput(input)],
+    });
+
+export const mintSyFromTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: MintSyFromTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, mintSyFromTokenCalldata(args));
+
+// ---- redeemSyToToken -------------------------------------------------------
+// Unwraps SY back to a token. Clean shape: pendleSwap=0, swapType=NONE.
+
+export type RedeemSyToTokenArgs = Readonly<{
+    receiver: Address;
+    sy: Address;
+    netSyIn: bigint;
+    output: TokenOutputParams;
+}>;
+
+export const redeemSyToTokenCalldata = ({ receiver, sy, netSyIn, output }: RedeemSyToTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "redeemSyToToken",
+        args: [receiver, sy, netSyIn, makeCleanTokenOutput(output)],
+    });
+
+export const redeemSyToTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RedeemSyToTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, redeemSyToTokenCalldata(args));
+
+// =============================================================================
+// ActionMiscV3 — Mint/Redeem PY (PT + YT)
+// =============================================================================
+
+// ---- mintPyFromToken -------------------------------------------------------
+
+export type MintPyFromTokenArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    minPyOut: bigint;
+    input: TokenInputParams;
+}>;
+
+export const mintPyFromTokenCalldata = ({ receiver, yt, minPyOut, input }: MintPyFromTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "mintPyFromToken",
+        args: [receiver, yt, minPyOut, makeCleanTokenInput(input)],
+    });
+
+export const mintPyFromTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: MintPyFromTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, mintPyFromTokenCalldata(args));
+
+// ---- redeemPyToToken -------------------------------------------------------
+
+export type RedeemPyToTokenArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    netPyIn: bigint;
+    output: TokenOutputParams;
+}>;
+
+export const redeemPyToTokenCalldata = ({ receiver, yt, netPyIn, output }: RedeemPyToTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "redeemPyToToken",
+        args: [receiver, yt, netPyIn, makeCleanTokenOutput(output)],
+    });
+
+export const redeemPyToTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RedeemPyToTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, redeemPyToTokenCalldata(args));
+
+// ---- mintPyFromSy ----------------------------------------------------------
+// No aggregator struct at all — the simplest mint path.
+
+export type MintPyFromSyArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    netSyIn: bigint;
+    minPyOut: bigint;
+}>;
+
+export const mintPyFromSyCalldata = ({ receiver, yt, netSyIn, minPyOut }: MintPyFromSyArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "mintPyFromSy",
+        args: [receiver, yt, netSyIn, minPyOut],
+    });
+
+export const mintPyFromSyTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: MintPyFromSyArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, mintPyFromSyCalldata(args));
+
+// ---- redeemPyToSy ----------------------------------------------------------
+// No aggregator struct at all.
+
+export type RedeemPyToSyArgs = Readonly<{
+    receiver: Address;
+    yt: Address;
+    netPyIn: bigint;
+    minSyOut: bigint;
+}>;
+
+export const redeemPyToSyCalldata = ({ receiver, yt, netPyIn, minSyOut }: RedeemPyToSyArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "redeemPyToSy",
+        args: [receiver, yt, netPyIn, minSyOut],
+    });
+
+export const redeemPyToSyTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RedeemPyToSyArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, redeemPyToSyCalldata(args));
+
+// =============================================================================
+// ActionSwapPTV3 — PT swaps
+// =============================================================================
+
+// ---- swapExactTokenForPt ---------------------------------------------------
+// Token → PT via SY. Input + limit forced clean.
+
+export type SwapExactTokenForPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minPtOut: bigint;
+    guess: ApproxParams;
+    input: TokenInputParams;
+}>;
+
+export const swapExactTokenForPtCalldata = ({
+    receiver,
+    market,
+    minPtOut,
+    guess,
+    input,
+}: SwapExactTokenForPtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactTokenForPt",
+        args: [receiver, market, minPtOut, guess, makeCleanTokenInput(input), EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactTokenForPtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactTokenForPtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactTokenForPtCalldata(args));
+
+// ---- swapExactSyForPt ------------------------------------------------------
+// SY → PT. No aggregator struct; limit forced clean.
+
+export type SwapExactSyForPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactSyIn: bigint;
+    minPtOut: bigint;
+    guess: ApproxParams;
+}>;
+
+export const swapExactSyForPtCalldata = ({
+    receiver,
+    market,
+    exactSyIn,
+    minPtOut,
+    guess,
+}: SwapExactSyForPtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactSyForPt",
+        args: [receiver, market, exactSyIn, minPtOut, guess, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactSyForPtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactSyForPtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactSyForPtCalldata(args));
+
+// ---- swapExactPtForToken ---------------------------------------------------
+// PT → token via SY. Output + limit forced clean.
+
+export type SwapExactPtForTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactPtIn: bigint;
+    output: TokenOutputParams;
+}>;
+
+export const swapExactPtForTokenCalldata = ({
+    receiver,
+    market,
+    exactPtIn,
+    output,
+}: SwapExactPtForTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactPtForToken",
+        args: [receiver, market, exactPtIn, makeCleanTokenOutput(output), EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactPtForTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactPtForTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactPtForTokenCalldata(args));
+
+// ---- swapExactPtForSy ------------------------------------------------------
+// PT → SY. No aggregator struct; limit forced clean.
+
+export type SwapExactPtForSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactPtIn: bigint;
+    minSyOut: bigint;
+}>;
+
+export const swapExactPtForSyCalldata = ({ receiver, market, exactPtIn, minSyOut }: SwapExactPtForSyArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactPtForSy",
+        args: [receiver, market, exactPtIn, minSyOut, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactPtForSyTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactPtForSyArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactPtForSyCalldata(args));
+
+// =============================================================================
+// ActionSwapYTV3 — YT swaps
+// =============================================================================
+
+// ---- swapExactTokenForYt ---------------------------------------------------
+// Token → YT via SY. Input + limit forced clean.
+
+export type SwapExactTokenForYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minYtOut: bigint;
+    guess: ApproxParams;
+    input: TokenInputParams;
+}>;
+
+export const swapExactTokenForYtCalldata = ({
+    receiver,
+    market,
+    minYtOut,
+    guess,
+    input,
+}: SwapExactTokenForYtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactTokenForYt",
+        args: [receiver, market, minYtOut, guess, makeCleanTokenInput(input), EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactTokenForYtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactTokenForYtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactTokenForYtCalldata(args));
+
+// ---- swapExactSyForYt ------------------------------------------------------
+// SY → YT. No aggregator struct; limit forced clean.
+
+export type SwapExactSyForYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactSyIn: bigint;
+    minYtOut: bigint;
+    guess: ApproxParams;
+}>;
+
+export const swapExactSyForYtCalldata = ({
+    receiver,
+    market,
+    exactSyIn,
+    minYtOut,
+    guess,
+}: SwapExactSyForYtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactSyForYt",
+        args: [receiver, market, exactSyIn, minYtOut, guess, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactSyForYtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactSyForYtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactSyForYtCalldata(args));
+
+// ---- swapExactYtForToken ---------------------------------------------------
+// YT → token via SY. Output + limit forced clean.
+
+export type SwapExactYtForTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactYtIn: bigint;
+    output: TokenOutputParams;
+}>;
+
+export const swapExactYtForTokenCalldata = ({
+    receiver,
+    market,
+    exactYtIn,
+    output,
+}: SwapExactYtForTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactYtForToken",
+        args: [receiver, market, exactYtIn, makeCleanTokenOutput(output), EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactYtForTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactYtForTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactYtForTokenCalldata(args));
+
+// ---- swapExactYtForSy ------------------------------------------------------
+// YT → SY. No aggregator struct; limit forced clean.
+
+export type SwapExactYtForSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    exactYtIn: bigint;
+    minSyOut: bigint;
+}>;
+
+export const swapExactYtForSyCalldata = ({ receiver, market, exactYtIn, minSyOut }: SwapExactYtForSyArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "swapExactYtForSy",
+        args: [receiver, market, exactYtIn, minSyOut, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const swapExactYtForSyTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: SwapExactYtForSyArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, swapExactYtForSyCalldata(args));
+
+// =============================================================================
+// ActionAddRemoveLiqV3 — add liquidity
+// =============================================================================
+
+// ---- addLiquiditySingleToken -----------------------------------------------
+// Token → LP (has price impact). Input + limit forced clean.
+
+export type AddLiquiditySingleTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minLpOut: bigint;
+    guess: ApproxParams;
+    input: TokenInputParams;
+}>;
+
+export const addLiquiditySingleTokenCalldata = ({
+    receiver,
+    market,
+    minLpOut,
+    guess,
+    input,
+}: AddLiquiditySingleTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquiditySingleToken",
+        args: [receiver, market, minLpOut, guess, makeCleanTokenInput(input), EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const addLiquiditySingleTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquiditySingleTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquiditySingleTokenCalldata(args));
+
+// ---- addLiquiditySingleSy --------------------------------------------------
+// SY → LP (has price impact). No aggregator struct; limit forced clean.
+
+export type AddLiquiditySingleSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netSyIn: bigint;
+    minLpOut: bigint;
+    guess: ApproxParams;
+}>;
+
+export const addLiquiditySingleSyCalldata = ({
+    receiver,
+    market,
+    netSyIn,
+    minLpOut,
+    guess,
+}: AddLiquiditySingleSyArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquiditySingleSy",
+        args: [receiver, market, netSyIn, minLpOut, guess, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const addLiquiditySingleSyTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquiditySingleSyArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquiditySingleSyCalldata(args));
+
+// ---- addLiquiditySinglePt --------------------------------------------------
+// PT → LP. No aggregator struct; limit forced clean.
+
+export type AddLiquiditySinglePtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netPtIn: bigint;
+    minLpOut: bigint;
+    guess: ApproxParams;
+}>;
+
+export const addLiquiditySinglePtCalldata = ({
+    receiver,
+    market,
+    netPtIn,
+    minLpOut,
+    guess,
+}: AddLiquiditySinglePtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquiditySinglePt",
+        args: [receiver, market, netPtIn, minLpOut, guess, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const addLiquiditySinglePtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquiditySinglePtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquiditySinglePtCalldata(args));
+
+// ---- addLiquiditySingleTokenKeepYt (ZPI) -----------------------------------
+// Token → LP + YT (Zero Price Impact). Input forced clean. No LimitOrderData param.
+
+export type AddLiquiditySingleTokenKeepYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    minLpOut: bigint;
+    minYtOut: bigint;
+    input: TokenInputParams;
+}>;
+
+export const addLiquiditySingleTokenKeepYtCalldata = ({
+    receiver,
+    market,
+    minLpOut,
+    minYtOut,
+    input,
+}: AddLiquiditySingleTokenKeepYtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquiditySingleTokenKeepYt",
+        args: [receiver, market, minLpOut, minYtOut, makeCleanTokenInput(input)],
+    });
+
+export const addLiquiditySingleTokenKeepYtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquiditySingleTokenKeepYtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquiditySingleTokenKeepYtCalldata(args));
+
+// ---- addLiquiditySingleSyKeepYt (ZPI) -------------------------------------
+// SY → LP + YT (Zero Price Impact). No aggregator struct, no LimitOrderData.
+// The cleanest ZPI path — Hosted API outputs=[market, YT] triggers this function.
+
+export type AddLiquiditySingleSyKeepYtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netSyIn: bigint;
+    minLpOut: bigint;
+    minYtOut: bigint;
+}>;
+
+export const addLiquiditySingleSyKeepYtCalldata = ({
+    receiver,
+    market,
+    netSyIn,
+    minLpOut,
+    minYtOut,
+}: AddLiquiditySingleSyKeepYtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquiditySingleSyKeepYt",
+        args: [receiver, market, netSyIn, minLpOut, minYtOut],
+    });
+
+export const addLiquiditySingleSyKeepYtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquiditySingleSyKeepYtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquiditySingleSyKeepYtCalldata(args));
+
+// ---- addLiquidityDualTokenAndPt --------------------------------------------
+// Token + PT → LP. Input forced clean. No LimitOrderData param.
+
+export type AddLiquidityDualTokenAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    input: TokenInputParams;
+    netPtDesired: bigint;
+    minLpOut: bigint;
+}>;
+
+export const addLiquidityDualTokenAndPtCalldata = ({
+    receiver,
+    market,
+    input,
+    netPtDesired,
+    minLpOut,
+}: AddLiquidityDualTokenAndPtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquidityDualTokenAndPt",
+        args: [receiver, market, makeCleanTokenInput(input), netPtDesired, minLpOut],
+    });
+
+export const addLiquidityDualTokenAndPtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquidityDualTokenAndPtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquidityDualTokenAndPtCalldata(args));
+
+// ---- addLiquidityDualSyAndPt -----------------------------------------------
+// SY + PT → LP. No aggregator struct at all — the simplest dual add path.
+
+export type AddLiquidityDualSyAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netSyDesired: bigint;
+    netPtDesired: bigint;
+    minLpOut: bigint;
+}>;
+
+export const addLiquidityDualSyAndPtCalldata = ({
+    receiver,
+    market,
+    netSyDesired,
+    netPtDesired,
+    minLpOut,
+}: AddLiquidityDualSyAndPtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "addLiquidityDualSyAndPt",
+        args: [receiver, market, netSyDesired, netPtDesired, minLpOut],
+    });
+
+export const addLiquidityDualSyAndPtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: AddLiquidityDualSyAndPtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, addLiquidityDualSyAndPtCalldata(args));
+
+// =============================================================================
+// ActionAddRemoveLiqV3 — remove liquidity
+// =============================================================================
+
+// ---- removeLiquiditySingleToken --------------------------------------------
+// LP → token via SY. Output + limit forced clean.
+
+export type RemoveLiquiditySingleTokenArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    output: TokenOutputParams;
+}>;
+
+export const removeLiquiditySingleTokenCalldata = ({
+    receiver,
+    market,
+    netLpToRemove,
+    output,
+}: RemoveLiquiditySingleTokenArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "removeLiquiditySingleToken",
+        args: [receiver, market, netLpToRemove, makeCleanTokenOutput(output), EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const removeLiquiditySingleTokenTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RemoveLiquiditySingleTokenArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, removeLiquiditySingleTokenCalldata(args));
+
+// ---- removeLiquiditySingleSy -----------------------------------------------
+// LP → SY. No aggregator struct; limit forced clean.
+
+export type RemoveLiquiditySingleSyArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    minSyOut: bigint;
+}>;
+
+export const removeLiquiditySingleSyCalldata = ({
+    receiver,
+    market,
+    netLpToRemove,
+    minSyOut,
+}: RemoveLiquiditySingleSyArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "removeLiquiditySingleSy",
+        args: [receiver, market, netLpToRemove, minSyOut, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const removeLiquiditySingleSyTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RemoveLiquiditySingleSyArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, removeLiquiditySingleSyCalldata(args));
+
+// ---- removeLiquiditySinglePt -----------------------------------------------
+// LP → PT. No aggregator struct; limit forced clean; needs ApproxParams.
+
+export type RemoveLiquiditySinglePtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    minPtOut: bigint;
+    guess: ApproxParams;
+}>;
+
+export const removeLiquiditySinglePtCalldata = ({
+    receiver,
+    market,
+    netLpToRemove,
+    minPtOut,
+    guess,
+}: RemoveLiquiditySinglePtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "removeLiquiditySinglePt",
+        args: [receiver, market, netLpToRemove, minPtOut, guess, EMPTY_LIMIT_ORDER_DATA],
+    });
+
+export const removeLiquiditySinglePtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RemoveLiquiditySinglePtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, removeLiquiditySinglePtCalldata(args));
+
+// ---- removeLiquidityDualTokenAndPt -----------------------------------------
+// LP → token + PT. Output forced clean. No LimitOrderData param.
+
+export type RemoveLiquidityDualTokenAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    output: TokenOutputParams;
+    minPtOut: bigint;
+}>;
+
+export const removeLiquidityDualTokenAndPtCalldata = ({
+    receiver,
+    market,
+    netLpToRemove,
+    output,
+    minPtOut,
+}: RemoveLiquidityDualTokenAndPtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "removeLiquidityDualTokenAndPt",
+        args: [receiver, market, netLpToRemove, makeCleanTokenOutput(output), minPtOut],
+    });
+
+export const removeLiquidityDualTokenAndPtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RemoveLiquidityDualTokenAndPtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, removeLiquidityDualTokenAndPtCalldata(args));
+
+// ---- removeLiquidityDualSyAndPt --------------------------------------------
+// LP → SY + PT. No aggregator struct at all.
+
+export type RemoveLiquidityDualSyAndPtArgs = Readonly<{
+    receiver: Address;
+    market: Address;
+    netLpToRemove: bigint;
+    minSyOut: bigint;
+    minPtOut: bigint;
+}>;
+
+export const removeLiquidityDualSyAndPtCalldata = ({
+    receiver,
+    market,
+    netLpToRemove,
+    minSyOut,
+    minPtOut,
+}: RemoveLiquidityDualSyAndPtArgs): HexString =>
+    encodeFunctionData({
+        abi: pendleRouterAbi,
+        functionName: "removeLiquidityDualSyAndPt",
+        args: [receiver, market, netLpToRemove, minSyOut, minPtOut],
+    });
+
+export const removeLiquidityDualSyAndPtTrx = ({
+    args,
+    routerAddress,
+}: {
+    args: RemoveLiquidityDualSyAndPtArgs;
+    routerAddress: Address;
+}): Unwrapable<Call> => routerTrx(routerAddress, removeLiquidityDualSyAndPtCalldata(args));