@sun-protocol/sun-sdk-protocols 0.1.0-beta.0

package/dist/chunk-YMGZDXI4.js

@@ -0,0 +1,1209 @@
+import {
+  SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID,
+  SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID,
+  V3LiquidityClient,
+  liquidityIntentScope
+} from "./chunk-L5TZCDPH.js";
+import {
+  planRouterPermit2Authorization
+} from "./chunk-OM4OW4KB.js";
+import {
+  evmHexToTronAddress,
+  normalizeLiquidityPercentage,
+  normalizeProtocolToken,
+  planApproval,
+  readMulticallRequired,
+  readRequiredContract
+} from "./chunk-C2YCVBPI.js";
+import {
+  applySlippageMax,
+  attachApprovalIntent,
+  createContextExecutor,
+  executeTransactionPlan,
+  nextPlanId,
+  normalizeBaseUnitAmount,
+  normalizeDeadline,
+  normalizeRecipient,
+  parseSlippage,
+  requireWalletAddress,
+  requireWalletSnapshot,
+  resolveProtocolContract,
+  slippageToBips
+} from "./chunk-VFVKMC4H.js";
+
+// src/liquidity/v2.ts
+import {
+  CurrencyAmount,
+  SDKError,
+  TRON_ZERO_ADDRESS,
+  assertTronAddress
+} from "@sun-protocol/sun-sdk-core";
+import {
+  Pair,
+  buildV2AddLiquidityAction,
+  buildV2AddLiquidityEthAction,
+  buildV2FactoryFeeToRead,
+  buildV2FactoryPairRead,
+  buildV2LpApproveAction,
+  buildV2PairAllowanceRead,
+  buildV2PairBalanceRead,
+  buildV2PairKLastRead,
+  buildV2PairReservesRead,
+  buildV2PairTotalSupplyRead,
+  buildV2RemoveLiquidityAction,
+  buildV2RemoveLiquidityEthAction,
+  computeV2PairAddress,
+  getV2AddLiquidityMinimums,
+  getV2RemoveLiquidityMinimums,
+  normalizeV2ReserveResult,
+  quoteV2LiquidityAmount
+} from "@sun-protocol/sun-sdk-sunswap-v2";
+var DEFAULT_SLIPPAGE = "0.5%";
+function parseContractInteger(value, label) {
+  const normalized = Array.isArray(value) && value.length === 1 ? value[0] : value;
+  if (normalized === null || normalized === void 0 || typeof normalized !== "string" && typeof normalized !== "number" && typeof normalized !== "bigint" && typeof normalized !== "object") {
+    throw new SDKError("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+  }
+  try {
+    const text = normalized.toString();
+    if (!/^\d+$/.test(text)) throw new Error("not an unsigned integer");
+    return BigInt(text).toString();
+  } catch {
+    throw new SDKError("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+  }
+}
+function parseContractAddress(value, label) {
+  const normalized = Array.isArray(value) && value.length === 1 ? value[0] : value;
+  if (typeof normalized !== "string") {
+    throw new SDKError("SDK_CONTRACT_ERROR", `${label} must be an address contract result`, { value });
+  }
+  try {
+    return /^0x[0-9a-fA-F]{40}$/.test(normalized) ? evmHexToTronAddress(normalized, label) : assertTronAddress(normalized, label);
+  } catch {
+    throw new SDKError("SDK_CONTRACT_ERROR", `${label} must be an address contract result`, { value });
+  }
+}
+function createPairContext(context, tokenAInput, tokenBInput) {
+  const tokenA = normalizeProtocolToken(context, tokenAInput, "tokenA");
+  const tokenB = normalizeProtocolToken(context, tokenBInput, "tokenB");
+  if (tokenA.token.equals(tokenB.token)) {
+    throw new SDKError("SDK_INVALID_ARGUMENT", "V2 liquidity tokens must be different", {
+      tokenA: tokenAInput,
+      tokenB: tokenBInput
+    });
+  }
+  return {
+    tokenA,
+    tokenB,
+    tokenAContract: tokenA.kind === "native" ? tokenA.wrappedContractAddress : tokenA.contractAddress,
+    tokenBContract: tokenB.kind === "native" ? tokenB.wrappedContractAddress : tokenB.contractAddress,
+    pair: computeV2PairAddress({
+      network: context.network,
+      tokenA: tokenA.kind === "native" ? tokenA.wrappedContractAddress : tokenA.contractAddress,
+      tokenB: tokenB.kind === "native" ? tokenB.wrappedContractAddress : tokenB.contractAddress
+    }),
+    tokenASortsBefore: tokenA.token.sortsBefore(tokenB.token)
+  };
+}
+function parsePairReserves(result, tokenASortsBefore) {
+  if (!Array.isArray(result) || result.length < 2) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 pair reserves result is malformed", { result });
+  }
+  let normalized;
+  try {
+    normalized = normalizeV2ReserveResult(result);
+  } catch {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 pair reserves result is malformed", { result });
+  }
+  const reserve0 = parseContractInteger(normalized.reserve0, "reserve0");
+  const reserve1 = parseContractInteger(normalized.reserve1, "reserve1");
+  return tokenASortsBefore ? { reserveA: reserve0, reserveB: reserve1 } : { reserveA: reserve1, reserveB: reserve0 };
+}
+function resolveAddAmounts(input) {
+  const reserveA = BigInt(input.reserves.reserveA);
+  const reserveB = BigInt(input.reserves.reserveB);
+  if (reserveA === 0n && reserveB === 0n) {
+    return { amountA: input.amountADesired, amountB: input.amountBDesired };
+  }
+  if (reserveA === 0n || reserveB === 0n) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 pair has inconsistent zero reserves", {
+      reserveA: input.reserves.reserveA,
+      reserveB: input.reserves.reserveB
+    });
+  }
+  const amountBOptimal = quoteV2LiquidityAmount(
+    input.amountADesired,
+    input.reserves.reserveA,
+    input.reserves.reserveB
+  );
+  if (BigInt(amountBOptimal) <= BigInt(input.amountBDesired)) {
+    return { amountA: input.amountADesired, amountB: amountBOptimal };
+  }
+  const amountAOptimal = quoteV2LiquidityAmount(
+    input.amountBDesired,
+    input.reserves.reserveB,
+    input.reserves.reserveA
+  );
+  if (BigInt(amountAOptimal) > BigInt(input.amountADesired)) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 pair reserve quote exceeds desired liquidity amounts", {
+      amountADesired: input.amountADesired,
+      amountBDesired: input.amountBDesired,
+      amountAOptimal,
+      amountBOptimal
+    });
+  }
+  return { amountA: amountAOptimal, amountB: input.amountBDesired };
+}
+function createPairEntity(pair, reserves) {
+  return new Pair(
+    CurrencyAmount.fromRawAmount(pair.tokenA.token, reserves.reserveA),
+    CurrencyAmount.fromRawAmount(pair.tokenB.token, reserves.reserveB)
+  );
+}
+function validateAddAmounts(pair, reserves, amounts) {
+  if (BigInt(amounts.amountA) === 0n || BigInt(amounts.amountB) === 0n) {
+    throw new SDKError("SDK_INVALID_ARGUMENT", "V2 add liquidity amounts must remain positive after reserve optimization", {
+      ...amounts,
+      ...reserves
+    });
+  }
+  if (BigInt(reserves.reserveA) !== 0n || BigInt(reserves.reserveB) !== 0n) return;
+  const pairEntity = createPairEntity(pair, reserves);
+  try {
+    pairEntity.getLiquidityMinted(
+      CurrencyAmount.fromRawAmount(pairEntity.liquidityToken, "0"),
+      CurrencyAmount.fromRawAmount(pair.tokenA.token, amounts.amountA),
+      CurrencyAmount.fromRawAmount(pair.tokenB.token, amounts.amountB)
+    );
+  } catch {
+    throw new SDKError("SDK_INVALID_ARGUMENT", "Initial V2 liquidity is too small to exceed MINIMUM_LIQUIDITY", {
+      ...amounts
+    });
+  }
+}
+async function planTokenApproval(input) {
+  if (input.token.kind === "native") return [];
+  const approval = await planApproval(
+    input.context,
+    {
+      asset: { type: "token", token: input.token.contractAddress },
+      owner: input.owner,
+      spender: input.router,
+      amount: input.amount
+    },
+    { mode: input.mode ?? "auto" }
+  );
+  return attachApprovalIntent(
+    approval.actions,
+    liquidityIntentScope(SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID, "add-liquidity"),
+    input.token.token.symbol ?? input.token.input
+  );
+}
+function buildAddAction(input) {
+  const options = {
+    network: input.context.network,
+    router: input.router,
+    recipient: input.recipient,
+    deadline: input.deadline,
+    id: `${input.planId}-tx`,
+    ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {}
+  };
+  const action = input.pair.tokenA.kind === "native" ? buildV2AddLiquidityEthAction({
+    ...options,
+    token: input.pair.tokenB.token,
+    amountTokenDesired: input.amountB,
+    amountEthDesired: input.amountA,
+    amountTokenMin: input.amountBMin,
+    amountEthMin: input.amountAMin
+  }) : input.pair.tokenB.kind === "native" ? buildV2AddLiquidityEthAction({
+    ...options,
+    token: input.pair.tokenA.token,
+    amountTokenDesired: input.amountA,
+    amountEthDesired: input.amountB,
+    amountTokenMin: input.amountAMin,
+    amountEthMin: input.amountBMin
+  }) : buildV2AddLiquidityAction({
+    ...options,
+    tokenA: input.pair.tokenA.token,
+    tokenB: input.pair.tokenB.token,
+    amountADesired: input.amountA,
+    amountBDesired: input.amountB,
+    amountAMin: input.amountAMin,
+    amountBMin: input.amountBMin
+  });
+  const intent = {
+    kind: "add-liquidity",
+    scope: liquidityIntentScope(SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID, "add-liquidity")
+  };
+  return {
+    ...action,
+    intent
+  };
+}
+function buildRemoveAction(input) {
+  const options = {
+    network: input.context.network,
+    router: input.router,
+    liquidity: input.liquidity,
+    recipient: input.recipient,
+    deadline: input.deadline,
+    id: `${input.planId}-tx`,
+    ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {}
+  };
+  let action;
+  if (input.pair.tokenA.kind === "native") {
+    action = buildV2RemoveLiquidityEthAction({
+      ...options,
+      token: input.pair.tokenB.token,
+      amountTokenMin: input.amountBMin,
+      amountEthMin: input.amountAMin
+    });
+  } else if (input.pair.tokenB.kind === "native") {
+    action = buildV2RemoveLiquidityEthAction({
+      ...options,
+      token: input.pair.tokenA.token,
+      amountTokenMin: input.amountAMin,
+      amountEthMin: input.amountBMin
+    });
+  } else {
+    action = buildV2RemoveLiquidityAction({
+      ...options,
+      tokenA: input.pair.tokenA.token,
+      tokenB: input.pair.tokenB.token,
+      amountAMin: input.amountAMin,
+      amountBMin: input.amountBMin
+    });
+  }
+  return {
+    ...action,
+    intent: {
+      kind: "remove-liquidity",
+      scope: liquidityIntentScope(SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID, "remove-liquidity")
+    }
+  };
+}
+function resolveRemoveLiquidity(input, balance) {
+  const hasLiquidity = input.liquidity !== void 0;
+  const hasPercentage = input.percentage !== void 0;
+  if (hasLiquidity === hasPercentage) {
+    throw new SDKError("SDK_INVALID_ARGUMENT", "V2 remove requires exactly one of liquidity or percentage");
+  }
+  const liquidity = hasLiquidity ? BigInt(normalizeBaseUnitAmount(input.liquidity, "liquidity")) : (() => {
+    const percentage = normalizeLiquidityPercentage(input.percentage, "percentage");
+    const numerator = BigInt(percentage.numerator.toString());
+    const denominator = BigInt(percentage.denominator.toString());
+    const result = BigInt(balance) * numerator / denominator;
+    if (result <= 0n) {
+      throw new SDKError("SDK_INVALID_ARGUMENT", "percentage resolves to zero liquidity", {
+        balance,
+        percentage: percentage.toSignificant()
+      });
+    }
+    return result;
+  })();
+  if (liquidity > BigInt(balance)) {
+    throw new SDKError("SDK_INVALID_ARGUMENT", "liquidity cannot exceed wallet LP balance", {
+      liquidity: liquidity.toString(),
+      balance
+    });
+  }
+  return liquidity.toString();
+}
+async function planV2AddLiquidity(context, input) {
+  const router = resolveProtocolContract(context, input.contracts, "sunswapV2Router");
+  const planId = nextPlanId(context, "liquidity-v2-add");
+  const owner = await requireWalletAddress(context, "V2 add liquidity");
+  const recipient = await normalizeRecipient(context, input.recipient, "V2 add liquidity", owner);
+  const deadline = normalizeDeadline(context, input);
+  const slippageInput = input.slippage ?? DEFAULT_SLIPPAGE;
+  const slippage = parseSlippage(slippageInput);
+  const pair = createPairContext(context, input.tokenA, input.tokenB);
+  const amountADesired = normalizeBaseUnitAmount(input.amountADesired, "amountADesired");
+  const amountBDesired = normalizeBaseUnitAmount(input.amountBDesired, "amountBDesired");
+  const deployedPair = parseContractAddress(await readRequiredContract(
+    context,
+    buildV2FactoryPairRead({
+      network: context.network,
+      tokenA: pair.tokenAContract,
+      tokenB: pair.tokenBContract
+    }),
+    "V2 add liquidity pair lookup"
+  ), "V2 factory pair");
+  if (deployedPair !== TRON_ZERO_ADDRESS && deployedPair !== pair.pair) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 factory pair does not match the configured CREATE2 pair", {
+      factoryPair: deployedPair,
+      computedPair: pair.pair
+    });
+  }
+  const reserves = deployedPair === TRON_ZERO_ADDRESS ? { reserveA: "0", reserveB: "0" } : parsePairReserves(await readRequiredContract(
+    context,
+    buildV2PairReservesRead(pair.pair),
+    "V2 add liquidity reserves"
+  ), pair.tokenASortsBefore);
+  const amounts = resolveAddAmounts({ amountADesired, amountBDesired, reserves });
+  validateAddAmounts(pair, reserves, amounts);
+  const slippageMinimums = getV2AddLiquidityMinimums(amounts, slippage);
+  const minimums = {
+    amountAMin: input.amountAMin === void 0 ? slippageMinimums.amountAMin : normalizeBaseUnitAmount(input.amountAMin, "amountAMin", { allowZero: true }),
+    amountBMin: input.amountBMin === void 0 ? slippageMinimums.amountBMin : normalizeBaseUnitAmount(input.amountBMin, "amountBMin", { allowZero: true })
+  };
+  const approvals = [
+    ...await planTokenApproval({ context, owner, token: pair.tokenA, amount: amounts.amountA, mode: input.approval, router }),
+    ...await planTokenApproval({ context, owner, token: pair.tokenB, amount: amounts.amountB, mode: input.approval, router })
+  ];
+  const transaction = buildAddAction({
+    context,
+    planId,
+    pair,
+    amountA: amounts.amountA,
+    amountB: amounts.amountB,
+    amountAMin: minimums.amountAMin,
+    amountBMin: minimums.amountBMin,
+    recipient,
+    deadline,
+    router,
+    ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {}
+  });
+  return {
+    id: planId,
+    kind: "liquidity",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Add SunSwap V2 liquidity",
+      lines: [`Pair ${pair.pair}`, `Recipient ${recipient}`]
+    },
+    approvals,
+    transactions: [transaction],
+    metadata: {
+      protocol: "sunswap-v2",
+      operation: "add-liquidity",
+      pair: pair.pair,
+      tokenA: input.tokenA,
+      tokenB: input.tokenB,
+      amountADesired,
+      amountBDesired,
+      amountA: amounts.amountA,
+      amountB: amounts.amountB,
+      amountAMin: minimums.amountAMin,
+      amountBMin: minimums.amountBMin,
+      owner,
+      recipient,
+      deadline,
+      slippageBips: slippageToBips(slippageInput),
+      approvalMode: input.approval ?? "auto"
+    }
+  };
+}
+async function planV2RemoveLiquidity(context, input) {
+  const router = resolveProtocolContract(context, input.contracts, "sunswapV2Router");
+  const planId = nextPlanId(context, "liquidity-v2-remove");
+  const owner = await requireWalletAddress(context, "V2 remove liquidity");
+  const recipient = await normalizeRecipient(context, input.recipient, "V2 remove liquidity", owner);
+  const deadline = normalizeDeadline(context, input);
+  const slippageInput = input.slippage ?? DEFAULT_SLIPPAGE;
+  const slippage = parseSlippage(slippageInput);
+  const approvalMode = input.approval ?? "auto";
+  if (approvalMode === "permit2") {
+    throw new SDKError("SDK_WALLET_CAPABILITY_ERROR", "Permit2 cannot authorize a SunSwap V2 LP token", {
+      approvalMode
+    });
+  }
+  const pair = createPairContext(context, input.tokenA, input.tokenB);
+  const [reservesResult, totalSupplyResult, balanceResult, feeToResult, kLastResult] = await readMulticallRequired(
+    context,
+    [
+      buildV2PairReservesRead(pair.pair),
+      buildV2PairTotalSupplyRead(pair.pair),
+      buildV2PairBalanceRead(pair.pair, owner),
+      buildV2FactoryFeeToRead({ network: context.network }),
+      buildV2PairKLastRead(pair.pair)
+    ],
+    "V2 remove liquidity state"
+  );
+  const reserves = parsePairReserves(reservesResult, pair.tokenASortsBefore);
+  const totalSupply = parseContractInteger(totalSupplyResult, "totalSupply");
+  const balance = parseContractInteger(balanceResult, "LP balance");
+  const feeTo = parseContractAddress(feeToResult, "V2 factory feeTo");
+  const kLast = parseContractInteger(kLastResult, "kLast");
+  const feeOn = feeTo !== TRON_ZERO_ADDRESS;
+  if (BigInt(totalSupply) === 0n) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 pair total supply must be positive", {
+      pair: pair.pair,
+      totalSupply
+    });
+  }
+  if (BigInt(reserves.reserveA) === 0n || BigInt(reserves.reserveB) === 0n) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 pair reserves must be positive for removal", {
+      pair: pair.pair,
+      reserveA: reserves.reserveA,
+      reserveB: reserves.reserveB
+    });
+  }
+  const liquidity = resolveRemoveLiquidity(input, balance);
+  if (BigInt(liquidity) > BigInt(totalSupply)) {
+    throw new SDKError("SDK_CONTRACT_ERROR", "V2 LP balance exceeds pair total supply", {
+      liquidity,
+      totalSupply
+    });
+  }
+  const pairEntity = createPairEntity(pair, reserves);
+  const totalSupplyAmount = CurrencyAmount.fromRawAmount(pairEntity.liquidityToken, totalSupply);
+  const liquidityAmount = CurrencyAmount.fromRawAmount(pairEntity.liquidityToken, liquidity);
+  const amountA = pairEntity.getLiquidityValue(
+    pair.tokenA.token,
+    totalSupplyAmount,
+    liquidityAmount,
+    feeOn,
+    kLast
+  ).quotient.toString();
+  const amountB = pairEntity.getLiquidityValue(
+    pair.tokenB.token,
+    totalSupplyAmount,
+    liquidityAmount,
+    feeOn,
+    kLast
+  ).quotient.toString();
+  if (BigInt(amountA) === 0n || BigInt(amountB) === 0n) {
+    throw new SDKError("SDK_INVALID_ARGUMENT", "V2 remove liquidity resolves to a zero token amount", {
+      liquidity,
+      amountA,
+      amountB
+    });
+  }
+  const minimums = getV2RemoveLiquidityMinimums({ amountA, amountB }, slippage);
+  const approvals = [];
+  if (approvalMode !== "none") {
+    const allowance = parseContractInteger(
+      await readRequiredContract(
+        context,
+        buildV2PairAllowanceRead(pair.pair, owner, router),
+        "V2 LP allowance"
+      ),
+      "LP allowance"
+    );
+    if (BigInt(allowance) < BigInt(liquidity)) {
+      approvals.push({
+        ...buildV2LpApproveAction({
+          pair: pair.pair,
+          spender: router,
+          amount: liquidity,
+          id: `${planId}-approve`,
+          ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {}
+        }),
+        intent: {
+          kind: "approve",
+          scope: liquidityIntentScope(SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID, "remove-liquidity"),
+          tokenSymbol: "LP"
+        }
+      });
+    }
+  }
+  const transaction = buildRemoveAction({
+    context,
+    planId,
+    pair,
+    liquidity,
+    amountAMin: minimums.amountAMin,
+    amountBMin: minimums.amountBMin,
+    recipient,
+    deadline,
+    router,
+    ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {}
+  });
+  return {
+    id: planId,
+    kind: "liquidity",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Remove SunSwap V2 liquidity",
+      lines: [`Pair ${pair.pair}`, `LP liquidity ${liquidity}`, `Recipient ${recipient}`]
+    },
+    approvals,
+    transactions: [transaction],
+    metadata: {
+      protocol: "sunswap-v2",
+      operation: "remove-liquidity",
+      pair: pair.pair,
+      tokenA: input.tokenA,
+      tokenB: input.tokenB,
+      liquidity,
+      amountA,
+      amountB,
+      amountAMin: minimums.amountAMin,
+      amountBMin: minimums.amountBMin,
+      owner,
+      recipient,
+      deadline,
+      slippageBips: slippageToBips(slippageInput),
+      approvalMode,
+      feeOn,
+      feeTo,
+      kLast
+    }
+  };
+}
+var V2LiquidityClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  add = {
+    plan: (input) => planV2AddLiquidity(this.context, input),
+    execute: async (input) => executeTransactionPlan(await planV2AddLiquidity(this.context, input), createContextExecutor(this.context))
+  };
+  remove = {
+    plan: (input) => planV2RemoveLiquidity(this.context, input),
+    execute: async (input) => executeTransactionPlan(await planV2RemoveLiquidity(this.context, input), createContextExecutor(this.context))
+  };
+};
+function createV2LiquidityClient(context) {
+  return new V2LiquidityClient(context);
+}
+
+// src/liquidity/v4.ts
+import {
+  SDKError as SDKError2,
+  TRON_ZERO_ADDRESS as TRON_ZERO_ADDRESS2,
+  assertTronAddress as assertTronAddress2
+} from "@sun-protocol/sun-sdk-core";
+import { TickMath } from "@sun-protocol/sun-sdk-sunswap-v3";
+import {
+  assertV4PoolId,
+  buildV4IncreaseLiquidityAction,
+  buildV4HookRegistrationBitmapRead,
+  buildV4InitializePoolAction,
+  buildV4MintPositionAction,
+  buildV4MulticallAction,
+  buildV4PoolAndPositionInfoRead,
+  buildV4PoolSlot0Read,
+  buildV4PoolStateReads,
+  computeV4PoolId,
+  createV4PoolKey,
+  decodeV4HooksRegistration,
+  encodeV4PoolParameters,
+  encodeV4ContractCallAction,
+  encodeV4Permit2ForwardCall
+} from "@sun-protocol/sun-sdk-sunswap-v4";
+var Q96 = 1n << 96n;
+function parseString(value, label) {
+  if (typeof value === "bigint" || typeof value === "number" || typeof value === "string") {
+    return BigInt(value.toString()).toString();
+  }
+  throw new SDKError2("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+}
+function parseNumber(value, label) {
+  const parsed = Number(parseString(value, label));
+  if (!Number.isSafeInteger(parsed)) {
+    throw new SDKError2("SDK_CONTRACT_ERROR", `${label} must be a safe integer`, { value });
+  }
+  return parsed;
+}
+function unwrapSingle(value) {
+  return Array.isArray(value) && value.length === 1 ? value[0] : value;
+}
+function signed24(value) {
+  const masked = value & 0xffffffn;
+  return Number((masked & 0x800000n) === 0n ? masked : masked - 0x1000000n);
+}
+function parsePackedPositionTicks(value) {
+  const info = BigInt(String(unwrapSingle(value)));
+  return {
+    tickLower: signed24(info >> 8n),
+    tickUpper: signed24(info >> 32n)
+  };
+}
+function parseV4Address(value, label) {
+  const raw = String(unwrapSingle(value));
+  try {
+    return assertTronAddress2(raw, label);
+  } catch {
+    const evmHex = /^41[0-9a-fA-F]{40}$/.test(raw) ? `0x${raw.slice(2)}` : raw;
+    return evmHexToTronAddress(evmHex, label);
+  }
+}
+function parsePositionPoolKey(value, network) {
+  if (Array.isArray(value) && value.length >= 5) {
+    return createV4PoolKey({
+      network,
+      currencyA: parseV4Address(value[0], "poolKey.currency0"),
+      currencyB: parseV4Address(value[1], "poolKey.currency1"),
+      hooks: parseV4Address(value[2], "poolKey.hooks"),
+      fee: parseNumber(value[3], "poolKey.fee"),
+      parameters: String(value[4])
+    });
+  }
+  if (typeof value === "object" && value !== null) {
+    const key = value;
+    if (key.currency0 !== void 0 && key.currency1 !== void 0 && key.hooks !== void 0 && key.fee !== void 0 && key.parameters !== void 0) {
+      return createV4PoolKey({
+        network,
+        currencyA: parseV4Address(key.currency0, "poolKey.currency0"),
+        currencyB: parseV4Address(key.currency1, "poolKey.currency1"),
+        hooks: parseV4Address(key.hooks, "poolKey.hooks"),
+        fee: parseNumber(key.fee, "poolKey.fee"),
+        parameters: String(key.parameters)
+      });
+    }
+  }
+  throw new SDKError2("SDK_CONTRACT_ERROR", "V4 position context is missing poolKey", { value });
+}
+function parseSlot0(result) {
+  if (Array.isArray(result)) {
+    return {
+      sqrtPriceX96: parseString(result[0], "sqrtPriceX96"),
+      tick: parseNumber(result[1], "tick")
+    };
+  }
+  if (typeof result === "object" && result !== null) {
+    const slot0 = result;
+    return {
+      sqrtPriceX96: parseString(slot0.sqrtPriceX96, "sqrtPriceX96"),
+      tick: parseNumber(slot0.tick, "tick")
+    };
+  }
+  throw new SDKError2("SDK_CONTRACT_ERROR", "V4 slot0 result is malformed", { result });
+}
+async function resolveV4PoolKey(context, input) {
+  if (input.poolKey !== void 0) {
+    return { poolKey: input.poolKey, derived: false, amountsSwapped: false };
+  }
+  if (input.token0 === void 0 || input.token1 === void 0 || input.fee === void 0 || input.tickSpacing === void 0) {
+    throw new SDKError2("SDK_INVALID_ARGUMENT", "V4 poolKey or complete token pool inputs are required");
+  }
+  const token0 = normalizeProtocolToken(context, input.token0, "token0").contractAddress;
+  const token1 = normalizeProtocolToken(context, input.token1, "token1").contractAddress;
+  const hooks = assertTronAddress2(input.hooks ?? TRON_ZERO_ADDRESS2, "hooks");
+  if (input.dynamicFee && hooks === TRON_ZERO_ADDRESS2) {
+    throw new SDKError2("SDK_INVALID_ARGUMENT", "Dynamic V4 fees require a non-zero hooks contract");
+  }
+  const hooksRegistration = input.hooksRegistration ?? (hooks === TRON_ZERO_ADDRESS2 ? 0 : parseNumber(
+    unwrapSingle(await readRequiredContract(
+      context,
+      buildV4HookRegistrationBitmapRead({ network: context.network, hooks }),
+      "V4 hook registration read"
+    )),
+    "hooksRegistration"
+  ));
+  const poolKey = createV4PoolKey({
+    network: context.network,
+    currencyA: token0,
+    currencyB: token1,
+    hooks,
+    fee: input.dynamicFee ? 8388608 : input.fee,
+    parameters: encodeV4PoolParameters({
+      tickSpacing: input.tickSpacing,
+      hooksRegistration: decodeV4HooksRegistration(hooksRegistration)
+    })
+  });
+  return {
+    poolKey,
+    derived: true,
+    amountsSwapped: poolKey.currency0 !== token0
+  };
+}
+function parseV4PositionContext(result, network) {
+  let poolKey;
+  let tickLower;
+  let tickUpper;
+  if (Array.isArray(result)) {
+    poolKey = result[0];
+    if (result[2] === void 0 && result[1] !== void 0) {
+      const ticks = parsePackedPositionTicks(result[1]);
+      tickLower = ticks.tickLower;
+      tickUpper = ticks.tickUpper;
+    } else {
+      tickLower = result[1];
+      tickUpper = result[2];
+    }
+  } else if (typeof result === "object" && result !== null) {
+    const info = result;
+    poolKey = info.poolKey;
+    tickLower = info.tickLower;
+    tickUpper = info.tickUpper;
+  } else {
+    throw new SDKError2("SDK_CONTRACT_ERROR", "V4 position context result is malformed", { result });
+  }
+  return {
+    poolKey: parsePositionPoolKey(poolKey, network),
+    tickLower: parseNumber(tickLower, "tickLower"),
+    tickUpper: parseNumber(tickUpper, "tickUpper")
+  };
+}
+function assertV4PoolKeyMatches(tokenId, supplied, position) {
+  const suppliedPoolId = computeV4PoolId(supplied);
+  const positionPoolId = computeV4PoolId(position);
+  if (suppliedPoolId !== positionPoolId) {
+    throw new SDKError2("SDK_INVALID_ARGUMENT", "V4 pool context does not match the tokenId position", {
+      tokenId,
+      suppliedPoolId,
+      positionPoolId
+    });
+  }
+}
+async function resolveV4PositionContext(context, tokenId, contracts) {
+  const result = await readRequiredContract(
+    context,
+    buildV4PoolAndPositionInfoRead({
+      network: context.network,
+      tokenId,
+      positionManager: resolveProtocolContract(context, contracts, "sunswapV4PositionManager")
+    }),
+    "V4 position context read"
+  );
+  return parseV4PositionContext(result, context.network);
+}
+async function shouldInitializeV4Pool(context, poolKey, input) {
+  if (!input.createPool) return { shouldInitialize: false };
+  if (input.poolInitializationMode === "trust-input") return { shouldInitialize: true };
+  try {
+    const slot0Result = await readRequiredContract(
+      context,
+      buildV4PoolSlot0Read({
+        network: context.network,
+        poolId: computeV4PoolId(poolKey),
+        poolManager: resolveProtocolContract(context, input.contracts, "sunswapV4PoolManager")
+      }),
+      "V4 pool initialization check"
+    );
+    const sqrtPriceX96 = parseSlot0(slot0Result).sqrtPriceX96;
+    return BigInt(sqrtPriceX96) === 0n ? { shouldInitialize: true } : { shouldInitialize: false, sqrtPriceX96 };
+  } catch {
+    return { shouldInitialize: true };
+  }
+}
+function maxV4LiquidityForAmounts(input) {
+  const sqrtPrice = BigInt(input.sqrtPriceX96);
+  let sqrtA = BigInt(TickMath.getSqrtRatioAtTick(input.tickLower).toString());
+  let sqrtB = BigInt(TickMath.getSqrtRatioAtTick(input.tickUpper).toString());
+  if (sqrtA > sqrtB) [sqrtA, sqrtB] = [sqrtB, sqrtA];
+  const amount0 = BigInt(input.amount0);
+  const amount1 = BigInt(input.amount1);
+  const difference = sqrtB - sqrtA;
+  let liquidity;
+  if (sqrtPrice <= sqrtA) {
+    liquidity = amount0 * sqrtA * sqrtB / (Q96 * difference);
+  } else if (sqrtPrice < sqrtB) {
+    const liquidity0 = amount0 * sqrtPrice * sqrtB / (Q96 * (sqrtB - sqrtPrice));
+    const liquidity1 = amount1 * Q96 / (sqrtPrice - sqrtA);
+    liquidity = liquidity0 < liquidity1 ? liquidity0 : liquidity1;
+  } else {
+    liquidity = amount1 * Q96 / difference;
+  }
+  return liquidity.toString();
+}
+async function resolveV4SqrtPrice(context, poolKey, input) {
+  if (input.createPool) {
+    if (input.sqrtPriceX96 === void 0) {
+      throw new SDKError2("SDK_INVALID_ARGUMENT", "sqrtPriceX96 is required when createPool is true");
+    }
+    return normalizeBaseUnitAmount(input.sqrtPriceX96, "sqrtPriceX96");
+  }
+  const slot0Result = await readRequiredContract(
+    context,
+    buildV4PoolSlot0Read({
+      network: context.network,
+      poolId: computeV4PoolId(poolKey),
+      poolManager: resolveProtocolContract(context, input.contracts, "sunswapV4PoolManager")
+    }),
+    "V4 pool state read"
+  );
+  return parseSlot0(slot0Result).sqrtPriceX96;
+}
+async function resolveV4LiquidityAmounts(context, input) {
+  const hasResolvedAmount = input.liquidity !== void 0 || input.amount0Max !== void 0 || input.amount1Max !== void 0;
+  if (hasResolvedAmount) {
+    if (input.liquidity === void 0 || input.amount0Max === void 0 || input.amount1Max === void 0) {
+      throw new SDKError2("SDK_INVALID_ARGUMENT", "liquidity, amount0Max, and amount1Max must be provided together");
+    }
+    return {
+      liquidity: normalizeBaseUnitAmount(input.liquidity, "liquidity"),
+      amount0Max: normalizeBaseUnitAmount(input.amount0Max, "amount0Max", { allowZero: true }),
+      amount1Max: normalizeBaseUnitAmount(input.amount1Max, "amount1Max", { allowZero: true }),
+      amount0Desired: normalizeBaseUnitAmount(input.amount0Max, "amount0Max", { allowZero: true }),
+      amount1Desired: normalizeBaseUnitAmount(input.amount1Max, "amount1Max", { allowZero: true }),
+      derived: false
+    };
+  }
+  if (input.amount0 === void 0 && input.amount1 === void 0) {
+    throw new SDKError2("SDK_INVALID_ARGUMENT", "V4 liquidity requires at least one of amount0 or amount1");
+  }
+  if (input.tickLower >= input.tickUpper) {
+    throw new SDKError2("SDK_INVALID_ARGUMENT", "tickLower must be less than tickUpper", {
+      tickLower: input.tickLower,
+      tickUpper: input.tickUpper
+    });
+  }
+  const userAmount0 = normalizeBaseUnitAmount(input.amount0 ?? "0", "amount0", { allowZero: true });
+  const userAmount1 = normalizeBaseUnitAmount(input.amount1 ?? "0", "amount1", { allowZero: true });
+  const amount0 = input.amountsSwapped ? userAmount1 : userAmount0;
+  const amount1 = input.amountsSwapped ? userAmount0 : userAmount1;
+  const liquidity = maxV4LiquidityForAmounts({
+    sqrtPriceX96: await resolveV4SqrtPrice(context, input.poolKey, input),
+    tickLower: input.tickLower,
+    tickUpper: input.tickUpper,
+    amount0,
+    amount1
+  });
+  if (BigInt(liquidity) <= 0n) {
+    throw new SDKError2("SDK_INVALID_ARGUMENT", "V4 amount inputs resolve to zero liquidity", {
+      amount0,
+      amount1,
+      tickLower: input.tickLower,
+      tickUpper: input.tickUpper
+    });
+  }
+  const slippageBips = slippageToBips(input.slippage ?? "0.5%");
+  const halfUp = (amount, bips) => ((amount * BigInt(1e4 + bips) + 5000n) / 10000n).toString();
+  return {
+    liquidity,
+    amount0Max: input.roundingMode === "half-up" ? halfUp(BigInt(amount0), slippageBips) : applySlippageMax(BigInt(amount0), slippageBips).toString(),
+    amount1Max: input.roundingMode === "half-up" ? halfUp(BigInt(amount1), slippageBips) : applySlippageMax(BigInt(amount1), slippageBips).toString(),
+    amount0Desired: amount0,
+    amount1Desired: amount1,
+    derived: true
+  };
+}
+function nativeCallValue(poolKey, amounts, mode) {
+  if (mode !== "desired") return void 0;
+  let value = 0n;
+  if (poolKey.currency0 === TRON_ZERO_ADDRESS2) value += BigInt(amounts.amount0Desired);
+  if (poolKey.currency1 === TRON_ZERO_ADDRESS2) value += BigInt(amounts.amount1Desired);
+  return value;
+}
+function planMetadata(input) {
+  return {
+    protocol: "sunswap-v4",
+    operation: input.operation,
+    ...input.poolId !== void 0 ? { poolId: input.poolId } : {},
+    ...input.tokenId !== void 0 ? { tokenId: input.tokenId } : {},
+    ...input.owner !== void 0 ? { owner: input.owner } : {},
+    ...input.sweepRecipient !== void 0 ? { sweepRecipient: input.sweepRecipient } : {},
+    ...input.deadline !== void 0 ? { deadline: input.deadline } : {},
+    ...input.poolKeyDerived !== void 0 ? { poolKeyDerived: input.poolKeyDerived } : {},
+    ...input.amountsDerived !== void 0 ? { amountsDerived: input.amountsDerived } : {},
+    ...input.createPool !== void 0 ? { createPool: input.createPool } : {}
+  };
+}
+async function approvalsFromV4Action(context, action, owner, mode, scope) {
+  const requirements = action.tokenRequirements ?? [];
+  const approvals = [];
+  for (const requirement of requirements) {
+    if (BigInt(requirement.amount) === 0n) continue;
+    if (mode === "none") continue;
+    const authorization = await planRouterPermit2Authorization(context, {
+      owner,
+      token: requirement.token,
+      spender: requirement.spender,
+      amount: requirement.amount,
+      approval: "approve"
+    });
+    for (const approval of authorization.actions) {
+      if (approval.type !== "approve" && approval.type !== "contract-call") {
+        throw new SDKError2(
+          "SDK_RUNTIME_ERROR",
+          "V4 Permit2 authorization produced a non-contract action",
+          { actionType: approval.type }
+        );
+      }
+      approvals.push(...attachApprovalIntent(
+        [approval],
+        scope,
+        requirement.token
+      ));
+    }
+  }
+  return approvals;
+}
+var V4LiquidityClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  async read(input) {
+    const poolId = assertV4PoolId(input.poolId);
+    const [slot0Result, liquidityResult] = await readMulticallRequired(
+      this.context,
+      buildV4PoolStateReads({
+        network: this.context.network,
+        poolId,
+        poolManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PoolManager")
+      }),
+      "V4 pool state read"
+    );
+    const slot0 = parseSlot0(slot0Result);
+    return {
+      protocol: "sunswap-v4",
+      poolId,
+      sqrtPriceX96: slot0.sqrtPriceX96,
+      tick: slot0.tick,
+      liquidity: parseString(liquidityResult, "liquidity")
+    };
+  }
+  initialize = {
+    plan: async (input) => this.planInitialize(input),
+    execute: async (input) => executeTransactionPlan(await this.planInitialize(input), createContextExecutor(this.context))
+  };
+  add = {
+    plan: async (input) => this.planMint(input),
+    execute: async (input) => executeTransactionPlan(await this.planMint(input), createContextExecutor(this.context))
+  };
+  increase = {
+    plan: async (input) => this.planIncrease(input),
+    execute: async (input) => executeTransactionPlan(await this.planIncrease(input), createContextExecutor(this.context))
+  };
+  async planInitialize(input) {
+    const { address: owner } = await requireWalletSnapshot(this.context, "V4 initialize pool");
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "liquidity-v4-initialize");
+    const poolKey = await resolveV4PoolKey(this.context, input);
+    const action = buildV4InitializePoolAction({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      sqrtPriceX96: normalizeBaseUnitAmount(input.sqrtPriceX96, "sqrtPriceX96"),
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const poolId = computeV4PoolId(poolKey.poolKey);
+    const transaction = {
+      ...action,
+      intent: {
+        kind: "create-pool",
+        scope: liquidityIntentScope(SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID, "initialize-pool"),
+        poolId
+      }
+    };
+    return {
+      id: planId,
+      kind: "liquidity",
+      network: this.context.network,
+      owner,
+      summary: {
+        title: "Initialize SunSwap V4 pool",
+        lines: [`Pool ${poolId}`]
+      },
+      approvals: [],
+      transactions: [transaction],
+      metadata: planMetadata({ operation: "initialize-pool", poolId, poolKeyDerived: poolKey.derived })
+    };
+  }
+  async planMint(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "liquidity-v4-mint");
+    const { address: walletAddress } = await requireWalletSnapshot(this.context, "V4 mint position");
+    const owner = input.owner !== void 0 ? assertTronAddress2(input.owner, "owner") : walletAddress;
+    if (owner !== walletAddress) {
+      throw new SDKError2("SDK_WALLET_ACCOUNT_MISMATCH", "V4 mint owner does not match the connected wallet", {
+        expectedAddress: owner,
+        actualAddress: walletAddress
+      });
+    }
+    const deadline = normalizeDeadline(this.context, input);
+    const poolKey = await resolveV4PoolKey(this.context, input);
+    const initialization = await shouldInitializeV4Pool(this.context, poolKey.poolKey, input);
+    const amounts = await resolveV4LiquidityAmounts(this.context, {
+      ...input,
+      poolKey: poolKey.poolKey,
+      amountsSwapped: poolKey.amountsSwapped,
+      ...initialization.sqrtPriceX96 !== void 0 ? { sqrtPriceX96: initialization.sqrtPriceX96 } : {},
+      ...initialization.shouldInitialize ? { createPool: true } : { createPool: false }
+    });
+    if (input.createPool && input.sqrtPriceX96 === void 0) {
+      throw new SDKError2("SDK_INVALID_ARGUMENT", "sqrtPriceX96 is required when createPool is true");
+    }
+    const hasNativeCurrency = poolKey.poolKey.currency0 === TRON_ZERO_ADDRESS2 || poolKey.poolKey.currency1 === TRON_ZERO_ADDRESS2;
+    const sweepRecipient = hasNativeCurrency ? input.sweepRecipient !== void 0 ? assertTronAddress2(input.sweepRecipient, "sweepRecipient") : owner : void 0;
+    const desiredNativeCallValue = nativeCallValue(poolKey.poolKey, amounts, input.nativeCallValueMode);
+    const action = buildV4MintPositionAction({
+      network: this.context.network,
+      positionManager,
+      positionConfig: { poolKey: poolKey.poolKey, tickLower: input.tickLower, tickUpper: input.tickUpper },
+      liquidity: amounts.liquidity,
+      amount0Max: amounts.amount0Max,
+      amount1Max: amounts.amount1Max,
+      owner,
+      deadline,
+      ...desiredNativeCallValue !== void 0 ? { callValue: desiredNativeCallValue } : {},
+      ...sweepRecipient !== void 0 ? { sweepRecipient } : {},
+      ...input.hookData !== void 0 ? { hookData: input.hookData } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const scope = liquidityIntentScope(
+      SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID,
+      initialization.shouldInitialize ? "initialize-and-mint" : "mint-position"
+    );
+    const approvals = await approvalsFromV4Action(this.context, action, owner, input.approval, scope);
+    const poolId = computeV4PoolId(poolKey.poolKey);
+    const initializeAction = initialization.shouldInitialize ? buildV4InitializePoolAction({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      sqrtPriceX96: normalizeBaseUnitAmount(input.sqrtPriceX96, "sqrtPriceX96"),
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-initialize`
+    }) : void 0;
+    const calls = [
+      ...(input.permit2Signatures ?? []).map((permit) => encodeV4Permit2ForwardCall({ owner, permit })),
+      ...initializeAction ? [encodeV4ContractCallAction(initializeAction)] : [],
+      encodeV4ContractCallAction(action)
+    ];
+    const transactionAction = initializeAction || input.transactionMode === "multicall" || (input.permit2Signatures?.length ?? 0) > 0 ? buildV4MulticallAction({
+      network: this.context.network,
+      positionManager,
+      calls,
+      ...action.callValue !== void 0 ? { callValue: action.callValue } : {},
+      ...action.tokenRequirements !== void 0 ? { tokenRequirements: action.tokenRequirements } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    }) : action;
+    const transaction = {
+      ...transactionAction,
+      waitForReceipt: "included",
+      intent: {
+        kind: "add-liquidity",
+        scope
+      }
+    };
+    return {
+      id: planId,
+      kind: "liquidity",
+      network: this.context.network,
+      owner,
+      summary: {
+        title: "Mint SunSwap V4 position",
+        lines: [`Pool ${poolId}`, `Owner ${owner}`]
+      },
+      approvals,
+      transactions: [transaction],
+      metadata: planMetadata({
+        operation: "mint-position",
+        poolId,
+        owner,
+        ...sweepRecipient !== void 0 ? { sweepRecipient } : {},
+        deadline,
+        poolKeyDerived: poolKey.derived,
+        amountsDerived: amounts.derived,
+        createPool: initialization.shouldInitialize
+      })
+    };
+  }
+  async planIncrease(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "liquidity-v4-increase");
+    const owner = await requireWalletAddress(this.context, "V4 increase liquidity");
+    const deadline = normalizeDeadline(this.context, input);
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const poolKeyNeedsPosition = input.poolKey === void 0 && input.token0 === void 0;
+    const position = await resolveV4PositionContext(this.context, tokenId, input.contracts);
+    const poolKey = poolKeyNeedsPosition ? { poolKey: position.poolKey, derived: true, amountsSwapped: false } : await resolveV4PoolKey(this.context, input);
+    assertV4PoolKeyMatches(tokenId, poolKey.poolKey, position.poolKey);
+    const amounts = await resolveV4LiquidityAmounts(this.context, {
+      ...input,
+      poolKey: poolKey.poolKey,
+      tickLower: position.tickLower,
+      tickUpper: position.tickUpper,
+      amountsSwapped: poolKey.amountsSwapped
+    });
+    const hasNativeCurrency = poolKey.poolKey.currency0 === TRON_ZERO_ADDRESS2 || poolKey.poolKey.currency1 === TRON_ZERO_ADDRESS2;
+    const sweepRecipient = hasNativeCurrency ? input.sweepRecipient !== void 0 ? assertTronAddress2(input.sweepRecipient, "sweepRecipient") : owner : void 0;
+    const desiredNativeCallValue = nativeCallValue(poolKey.poolKey, amounts, input.nativeCallValueMode);
+    const action = buildV4IncreaseLiquidityAction({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      tokenId,
+      liquidity: amounts.liquidity,
+      amount0Max: amounts.amount0Max,
+      amount1Max: amounts.amount1Max,
+      deadline,
+      ...desiredNativeCallValue !== void 0 ? { callValue: desiredNativeCallValue } : {},
+      ...sweepRecipient !== void 0 ? { sweepRecipient } : {},
+      ...input.hookData !== void 0 ? { hookData: input.hookData } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const scope = liquidityIntentScope(SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID, "increase-liquidity");
+    const approvals = await approvalsFromV4Action(this.context, action, owner, input.approval, scope);
+    const poolId = computeV4PoolId(poolKey.poolKey);
+    const permitCalls = (input.permit2Signatures ?? []).map((permit) => encodeV4Permit2ForwardCall({ owner, permit }));
+    const transactionAction = input.transactionMode === "multicall" || permitCalls.length > 0 ? buildV4MulticallAction({
+      network: this.context.network,
+      positionManager,
+      calls: [...permitCalls, encodeV4ContractCallAction(action)],
+      ...action.callValue !== void 0 ? { callValue: action.callValue } : {},
+      ...action.tokenRequirements !== void 0 ? { tokenRequirements: action.tokenRequirements } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    }) : action;
+    const transaction = {
+      ...transactionAction,
+      waitForReceipt: "included",
+      intent: {
+        kind: "add-liquidity",
+        scope,
+        positionId: tokenId
+      }
+    };
+    return {
+      id: planId,
+      kind: "liquidity",
+      network: this.context.network,
+      owner,
+      summary: {
+        title: "Increase SunSwap V4 liquidity",
+        lines: [`Position ${tokenId}`, `Pool ${poolId}`]
+      },
+      approvals,
+      transactions: [transaction],
+      metadata: planMetadata({
+        operation: "increase-liquidity",
+        poolId,
+        tokenId,
+        owner,
+        ...sweepRecipient !== void 0 ? { sweepRecipient } : {},
+        deadline,
+        poolKeyDerived: poolKey.derived,
+        amountsDerived: amounts.derived
+      })
+    };
+  }
+};
+
+// src/liquidity/client.ts
+var LiquidityClient = class {
+  v4;
+  v3;
+  v2;
+  constructor(context) {
+    this.v2 = new V2LiquidityClient(context);
+    const v3Client = new V3LiquidityClient(context);
+    const v4Client = new V4LiquidityClient(context);
+    this.v3 = {
+      add: v3Client.add,
+      increase: v3Client.increase
+    };
+    this.v4 = {
+      initialize: v4Client.initialize,
+      read: (input) => v4Client.read(input),
+      add: v4Client.add,
+      increase: v4Client.increase
+    };
+  }
+};
+function createLiquidityClient(context) {
+  return new LiquidityClient(context);
+}
+
+export {
+  planV2AddLiquidity,
+  planV2RemoveLiquidity,
+  V2LiquidityClient,
+  createV2LiquidityClient,
+  V4LiquidityClient,
+  LiquidityClient,
+  createLiquidityClient
+};
+//# sourceMappingURL=chunk-YMGZDXI4.js.map