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

package/dist/liquidity/index.cjs

@@ -0,0 +1,2441 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/liquidity/index.ts
+var liquidity_exports = {};
+__export(liquidity_exports, {
+  LiquidityClient: () => LiquidityClient,
+  SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID: () => SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID,
+  SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID: () => SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID,
+  SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID: () => SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID,
+  V2LiquidityClient: () => V2LiquidityClient,
+  V3LiquidityClient: () => V3LiquidityClient,
+  V4LiquidityClient: () => V4LiquidityClient,
+  createLiquidityClient: () => createLiquidityClient,
+  createV2LiquidityClient: () => createV2LiquidityClient,
+  planV2AddLiquidity: () => planV2AddLiquidity,
+  planV2RemoveLiquidity: () => planV2RemoveLiquidity
+});
+module.exports = __toCommonJS(liquidity_exports);
+
+// src/liquidity/v2.ts
+var import_sun_sdk_core10 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_sunswap_v22 = require("@sun-protocol/sun-sdk-sunswap-v2");
+
+// src/approval/plan.ts
+var import_sun_sdk_core5 = require("@sun-protocol/sun-sdk-core");
+
+// src/common.ts
+var import_sun_sdk_core3 = require("@sun-protocol/sun-sdk-core");
+
+// src/context.ts
+var import_sun_sdk_api2 = require("@sun-protocol/sun-sdk-api");
+var import_sun_sdk_chains = require("@sun-protocol/sun-sdk-chains");
+var import_sun_sdk_core2 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_runtime = require("@sun-protocol/sun-sdk-runtime");
+
+// src/execute-http-action.ts
+var import_sun_sdk_api = require("@sun-protocol/sun-sdk-api");
+var import_sun_sdk_core = require("@sun-protocol/sun-sdk-core");
+async function executeHttpAction(action, fetchImpl, jsonParser = import_sun_sdk_api.defaultJsonParser) {
+  if (action.type !== "http-request" || action.execute !== "api") {
+    throw new import_sun_sdk_core.SDKError("SDK_INVALID_ARGUMENT", `Action ${action.id} is not an HTTP action`, {
+      actionId: action.id,
+      actionType: action.type
+    });
+  }
+  const request = action.request;
+  const headers = {
+    Accept: "application/json",
+    ...request.headers
+  };
+  let body;
+  if (request.body !== void 0) {
+    if (typeof request.body === "string") {
+      body = request.body;
+    } else {
+      body = JSON.stringify(request.body);
+      if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+    }
+  }
+  return (0, import_sun_sdk_api.requestJson)(request.url, {
+    service: "Protocols HTTP action",
+    fetchImpl,
+    jsonParser,
+    init: {
+      method: request.method,
+      headers,
+      ...body !== void 0 ? { body } : {}
+    }
+  });
+}
+
+// src/context.ts
+function requireRuntime(context, operation) {
+  if (!context.runtime) {
+    throw new import_sun_sdk_core2.SDKError("SDK_RUNTIME_ERROR", `${operation} requires a runtime`, {
+      operation,
+      network: context.network
+    });
+  }
+  return context.runtime;
+}
+function resolveProtocolContract(context, overrides, name) {
+  const configured = context.chain.contracts;
+  const address = overrides?.[name] ?? configured[name];
+  if (!address) {
+    throw new import_sun_sdk_core2.SDKError("SDK_INVALID_ARGUMENT", `No configured address for ${name}`, { name });
+  }
+  return (0, import_sun_sdk_core2.assertTronAddress)(address, name);
+}
+async function requireWalletAddress(context, operation) {
+  return (await requireWalletSnapshot(context, operation)).address;
+}
+async function requireWalletSnapshot(context, operation) {
+  const runtime = requireRuntime(context, operation);
+  const wallet = await runtime.requireWallet(operation);
+  return {
+    wallet,
+    address: (0, import_sun_sdk_core2.assertTronAddress)(await wallet.getAddress(), "wallet address")
+  };
+}
+function createContextExecutor(context) {
+  const runtime = context.runtime;
+  let walletPromise;
+  const requireExecutionWallet = () => {
+    walletPromise ??= runtime?.requireWallet("transaction plan execution");
+    if (!walletPromise) {
+      return Promise.reject(new import_sun_sdk_core2.SDKError("SDK_RUNTIME_ERROR", "Transaction plan execution requires a runtime"));
+    }
+    return walletPromise;
+  };
+  return {
+    network: context.network,
+    ...runtime ? {
+      getAddress: async () => {
+        const wallet = await requireExecutionWallet();
+        return (0, import_sun_sdk_core2.assertTronAddress)(await wallet.getAddress(), "wallet address");
+      },
+      sendAction: async (action) => {
+        const wallet = await requireExecutionWallet();
+        return runtime.sendAction(action, { wallet });
+      },
+      ...runtime.waitForTransactionReceipt ? { waitForTransactionReceipt: runtime.waitForTransactionReceipt.bind(runtime) } : {},
+      signTypedData: async (payload) => {
+        const wallet = await requireExecutionWallet();
+        return runtime.signTypedData(payload, { wallet });
+      }
+    } : {},
+    executeHttpAction: (action) => executeHttpAction(action, context.fetchImpl, context.jsonParser)
+  };
+}
+
+// src/common.ts
+var PERCENT_PATTERN = /^(\d+)(?:\.(\d+))?%$/;
+var BASE_UNIT_PATTERN = /^\d+$/;
+function parseSlippage(value) {
+  if (value instanceof import_sun_sdk_core3.Percent) {
+    validateSlippage(value);
+    return value;
+  }
+  const match = PERCENT_PATTERN.exec(value);
+  if (!match) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "Slippage must be a percentage string", {
+      slippage: value
+    });
+  }
+  const whole = match[1] ?? "0";
+  const fraction = match[2] ?? "";
+  const scale = 10n ** BigInt(fraction.length);
+  const percentageUnits = BigInt(whole) * scale + BigInt(fraction || "0");
+  const percent = new import_sun_sdk_core3.Percent(percentageUnits.toString(), (100n * scale).toString());
+  validateSlippage(percent);
+  return percent;
+}
+function validateSlippage(value) {
+  if (value.lessThan(0) || value.greaterThan(1)) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "Slippage must be between 0% and 100%", {
+      slippage: value.toSignificant()
+    });
+  }
+}
+function slippageToBips(value) {
+  const percent = parseSlippage(value);
+  const numerator = BigInt(percent.numerator.toString()) * 10000n;
+  const denominator = BigInt(percent.denominator.toString());
+  if (numerator % denominator !== 0n) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "Slippage must resolve to a whole basis point", {
+      slippage: typeof value === "string" ? value : value.toSignificant()
+    });
+  }
+  return Number(numerator / denominator);
+}
+function applySlippageMax(expected, slippageBips) {
+  const numerator = expected * BigInt(1e4 + slippageBips);
+  return (numerator + 9999n) / 10000n;
+}
+function normalizeBaseUnitAmount(value, label = "amount", options = {}) {
+  if (typeof value === "number" && !Number.isSafeInteger(value)) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", `${label} must be a safe integer`, {
+      label,
+      value
+    });
+  }
+  const text = value.toString();
+  if (!BASE_UNIT_PATTERN.test(text)) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", `${label} must be an unsigned base-unit integer`, {
+      label,
+      value: text
+    });
+  }
+  const amount = BigInt(text);
+  if (options.allowZero ? amount < 0n : amount <= 0n) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", `${label} must be ${options.allowZero ? "non-negative" : "positive"}`, {
+      label,
+      value: text
+    });
+  }
+  return amount.toString();
+}
+function normalizeDeadline(context, options = {}) {
+  if (options.deadline !== void 0) {
+    return normalizeBaseUnitAmount(options.deadline, "deadline");
+  }
+  const ttlSeconds = options.ttlSeconds ?? 1200;
+  if (!Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0) {
+    throw new import_sun_sdk_core3.SDKError("SDK_INVALID_ARGUMENT", "ttlSeconds must be a positive safe integer", {
+      ttlSeconds
+    });
+  }
+  return (BigInt(Math.floor(context.now() / 1e3)) + BigInt(ttlSeconds)).toString();
+}
+async function normalizeRecipient(context, recipient, operation, walletAddress) {
+  if (recipient !== void 0) return (0, import_sun_sdk_core3.assertTronAddress)(recipient, "recipient");
+  if (walletAddress !== void 0) return walletAddress;
+  return requireWalletAddress(context, operation);
+}
+function nextPlanId(context, prefix) {
+  return `${prefix}-${context.idFactory()}`;
+}
+
+// src/approval/check.ts
+async function readClassicAllowance(runtime, requirement) {
+  if (requirement.asset.type === "native") return "0";
+  const result = await runtime.readContract({
+    target: requirement.asset.token,
+    functionSelector: "allowance(address,address)",
+    parameters: [
+      { type: "address", value: requirement.owner },
+      { type: "address", value: requirement.spender }
+    ],
+    outputs: [{ type: "uint256", name: "allowance" }]
+  });
+  return BigInt(result).toString();
+}
+async function checkClassicAllowance(runtime, requirement) {
+  if (requirement.asset.type === "native") {
+    return { allowance: requirement.amount, sufficient: true };
+  }
+  const allowance = await readClassicAllowance(runtime, requirement);
+  return {
+    allowance,
+    sufficient: BigInt(allowance) >= BigInt(requirement.amount)
+  };
+}
+
+// src/approval/classic.ts
+var import_sun_sdk_core4 = require("@sun-protocol/sun-sdk-core");
+function buildClassicApproveAction(requirement, options = {}) {
+  if (requirement.asset.type === "native") return void 0;
+  return (0, import_sun_sdk_core4.createApproveAction)({
+    id: `approve-${requirement.asset.token}-${requirement.spender}`,
+    target: requirement.asset.token,
+    spender: requirement.spender,
+    amount: options.amount === "exact" ? requirement.amount : import_sun_sdk_core4.MaxUint256.toString(),
+    ...options.feeLimit !== void 0 ? { feeLimit: options.feeLimit } : {}
+  });
+}
+
+// src/approval/plan.ts
+async function planApproval(context, requirement, options = {}) {
+  const mode = options.mode ?? "auto";
+  normalizeBaseUnitAmount(requirement.amount, "approval amount");
+  if (requirement.asset.type === "native") {
+    return {
+      mode,
+      requirement,
+      allowance: requirement.amount,
+      sufficient: true,
+      actions: []
+    };
+  }
+  if (mode === "none") {
+    return { mode, requirement, actions: [] };
+  }
+  if (mode === "permit2") {
+    throw new import_sun_sdk_core5.SDKError(
+      "SDK_WALLET_CAPABILITY_ERROR",
+      "Permit2 approval is unavailable until a Permit2 adapter is configured",
+      { mode, token: requirement.asset.token }
+    );
+  }
+  const runtime = requireRuntime(context, "Token allowance check");
+  const check = await checkClassicAllowance(runtime, requirement);
+  if (check.sufficient) {
+    return {
+      mode,
+      requirement,
+      allowance: check.allowance,
+      sufficient: true,
+      actions: []
+    };
+  }
+  const action = buildClassicApproveAction(requirement, options);
+  return {
+    mode,
+    requirement,
+    allowance: check.allowance,
+    sufficient: false,
+    actions: action ? [action] : []
+  };
+}
+
+// src/execute-plan.ts
+var import_sun_sdk_core7 = require("@sun-protocol/sun-sdk-core");
+
+// src/errors.ts
+var import_sun_sdk_core6 = require("@sun-protocol/sun-sdk-core");
+function isWalletRejection(error) {
+  if (!error || typeof error !== "object") return false;
+  const candidate = error;
+  return candidate.code === 4001 || typeof candidate.message === "string" && /reject|denied|cancel/i.test(candidate.message);
+}
+function normalizeProtocolError(error, fallbackCode, message, context = {}) {
+  if (error instanceof import_sun_sdk_core6.SDKError) return error;
+  const code = isWalletRejection(error) ? "SDK_WALLET_REJECTED" : fallbackCode;
+  return new import_sun_sdk_core6.SDKError(code, message, { ...context, cause: error });
+}
+function withExecutionContext(error, context) {
+  return new import_sun_sdk_core6.SDKError(error.code, error.message, {
+    ...error.context,
+    actionId: context.actionId,
+    completedActionIds: context.completedActionIds,
+    cause: error
+  });
+}
+
+// src/execute-plan.ts
+async function executePlanAction(action, executor, completedActions = []) {
+  try {
+    if (action.waitForReceipt && !executor.waitForTransactionReceipt) {
+      throw new import_sun_sdk_core7.SDKError(
+        "SDK_RUNTIME_ERROR",
+        `Action ${action.id} requires transaction receipt waiting capability`,
+        { actionId: action.id, finality: action.waitForReceipt }
+      );
+    }
+    if (action.execute === "runtime") {
+      let actionToSend;
+      let materializedAction;
+      if (action.type === "deferred-contract-call") {
+        if (!executor.materializeAction) {
+          throw new import_sun_sdk_core7.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires a deferred action materializer`);
+        }
+        const resolvedAction = await executor.materializeAction(action, completedActions);
+        materializedAction = {
+          ...resolvedAction,
+          id: action.id,
+          ...action.intent === void 0 ? {} : { intent: action.intent }
+        };
+        actionToSend = materializedAction;
+      } else if (action.type === "contract-call" || action.type === "approve") {
+        actionToSend = action;
+      } else {
+        throw new import_sun_sdk_core7.SDKError(
+          "SDK_RUNTIME_ERROR",
+          `Runtime action ${action.id} materialized to unsupported type: ${action.type}`
+        );
+      }
+      if (!executor.sendAction) {
+        throw new import_sun_sdk_core7.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires a runtime executor`);
+      }
+      const result = await executor.sendAction(actionToSend);
+      const receipt = action.waitForReceipt && executor.waitForTransactionReceipt ? await executor.waitForTransactionReceipt(result.txid, { finality: action.waitForReceipt }) : void 0;
+      if (receipt && !receipt.success) {
+        throw new import_sun_sdk_core7.SDKError("SDK_CONTRACT_ERROR", `Transaction ${result.txid} failed`, {
+          actionId: action.id,
+          txid: result.txid,
+          receipt
+        });
+      }
+      return {
+        action,
+        result,
+        txid: result.txid,
+        ...receipt ? { receipt } : {},
+        ...materializedAction ? { materializedAction } : {}
+      };
+    }
+    if (action.execute === "wallet-signature") {
+      if (!action.typedData) {
+        throw new import_sun_sdk_core7.SDKError("SDK_INVALID_ARGUMENT", `Action ${action.id} is missing typedData`);
+      }
+      if (!executor.signTypedData) {
+        throw new import_sun_sdk_core7.SDKError("SDK_WALLET_CAPABILITY_ERROR", `Action ${action.id} requires typed-data signing`);
+      }
+      const signature = await executor.signTypedData(action.typedData);
+      return { action, result: signature };
+    }
+    if (action.execute === "api") {
+      if (!executor.executeHttpAction) {
+        throw new import_sun_sdk_core7.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires an API executor`);
+      }
+      return { action, result: await executor.executeHttpAction(action) };
+    }
+    throw new import_sun_sdk_core7.SDKError("SDK_RUNTIME_ERROR", "Unsupported action executor");
+  } catch (error) {
+    const normalized = normalizeProtocolError(
+      error,
+      action.execute === "api" ? "SDK_API_ERROR" : "SDK_RUNTIME_ERROR",
+      `Failed to execute action ${action.id}`
+    );
+    throw withExecutionContext(normalized, {
+      actionId: action.id,
+      completedActionIds: completedActions.map((result) => result.action.id)
+    });
+  }
+}
+async function executeTransactionPlan(plan, executor) {
+  if (executor.network && executor.network !== plan.network) {
+    throw new import_sun_sdk_core7.SDKError("SDK_INVALID_ARGUMENT", "Plan and executor network mismatch", {
+      planNetwork: plan.network,
+      executorNetwork: executor.network
+    });
+  }
+  if (plan.owner) {
+    if (!executor.getAddress) {
+      throw new import_sun_sdk_core7.SDKError("SDK_RUNTIME_ERROR", `Plan ${plan.id} requires a wallet address`, {
+        planId: plan.id,
+        owner: plan.owner
+      });
+    }
+    const actualAddress = await executor.getAddress();
+    if (actualAddress !== plan.owner) {
+      throw new import_sun_sdk_core7.SDKError(
+        "SDK_WALLET_ACCOUNT_MISMATCH",
+        "Transaction plan was created for a different wallet",
+        {
+          planId: plan.id,
+          expectedAddress: plan.owner,
+          actualAddress
+        }
+      );
+    }
+  }
+  const orderedActions = [...plan.approvals, ...plan.transactions];
+  const receiptAction = orderedActions.find((action) => action.waitForReceipt !== void 0);
+  if (receiptAction && !executor.waitForTransactionReceipt) {
+    throw new import_sun_sdk_core7.SDKError(
+      "SDK_RUNTIME_ERROR",
+      `Action ${receiptAction.id} requires transaction receipt waiting capability`,
+      { planId: plan.id, actionId: receiptAction.id, finality: receiptAction.waitForReceipt }
+    );
+  }
+  const actionResults = [];
+  const txids = [];
+  let finalResult;
+  for (const action of orderedActions) {
+    const actionResult = await executePlanAction(action, executor, actionResults);
+    actionResults.push(actionResult);
+    if (action.execute === "runtime") {
+      if (!actionResult.txid) {
+        throw new import_sun_sdk_core7.SDKError("SDK_RUNTIME_ERROR", `Runtime action ${action.id} did not return a transaction id`);
+      }
+      txids.push(actionResult.txid);
+      const raw = typeof actionResult.result === "object" && actionResult.result !== null ? actionResult.result.raw : void 0;
+      finalResult = { type: "transaction", txid: actionResult.txid, raw };
+      continue;
+    }
+    if (action.execute === "wallet-signature") {
+      finalResult = { type: "signature", signature: actionResult.result };
+      continue;
+    }
+    finalResult = { type: "api", data: actionResult.result };
+  }
+  return {
+    plan,
+    actions: actionResults,
+    txids,
+    finalResult
+  };
+}
+
+// src/internal/reads.ts
+var import_sun_sdk_core8 = require("@sun-protocol/sun-sdk-core");
+async function readRequiredContract(context, call, operation) {
+  const runtime = requireRuntime(context, operation);
+  const value = await runtime.readContract(call);
+  if (value === void 0 || value === null) {
+    throw new import_sun_sdk_core8.SDKError("SDK_CONTRACT_ERROR", `${operation} returned an empty result`, { call });
+  }
+  return value;
+}
+async function readMulticallRequired(context, calls, operation) {
+  const runtime = requireRuntime(context, operation);
+  const results = await runtime.multicall(calls);
+  return results.map((result, index) => {
+    if (!result.success || result.value === void 0) {
+      throw new import_sun_sdk_core8.SDKError("SDK_CONTRACT_ERROR", `${operation} multicall item failed`, {
+        index,
+        call: calls[index],
+        error: result.error
+      });
+    }
+    return result.value;
+  });
+}
+
+// src/internal/tokens.ts
+var import_sun_sdk_chains2 = require("@sun-protocol/sun-sdk-chains");
+var import_sun_sdk_core9 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_sunswap_v2 = require("@sun-protocol/sun-sdk-sunswap-v2");
+var PERCENT_PATTERN2 = /^(\d+)(?:\.(\d+))?%$/;
+function isNativeTrxInput(context, token) {
+  return token.toUpperCase() === "TRX" || token === context.chain.contracts.trx;
+}
+function evmHexToTronAddress(address, label = "address") {
+  const normalized = address.startsWith("0x") ? address.toLowerCase() : `0x${address.toLowerCase()}`;
+  return (0, import_sun_sdk_sunswap_v2.evmHexToTronAddress)(normalized, label);
+}
+function tronAddressToEvmAddress(address, label = "address") {
+  return `0x${(0, import_sun_sdk_sunswap_v2.tronAddressToEvmHex)((0, import_sun_sdk_core9.assertTronAddress)(address, label))}`;
+}
+function normalizeProtocolToken(context, token, label, metadata = {}) {
+  const wrappedContractAddress = (0, import_sun_sdk_chains2.getWrappedNativeAddress)(context.network);
+  const kind = isNativeTrxInput(context, token) ? "native" : "token";
+  const contractAddress = kind === "native" ? import_sun_sdk_core9.TRON_ZERO_ADDRESS : (0, import_sun_sdk_core9.assertTronAddress)(token, label);
+  const mathAddress = kind === "native" ? wrappedContractAddress : contractAddress;
+  const evmAddress = `0x${(0, import_sun_sdk_sunswap_v2.tronAddressToEvmHex)(mathAddress)}`.toLowerCase();
+  return {
+    kind,
+    input: token,
+    contractAddress,
+    wrappedContractAddress,
+    token: new import_sun_sdk_core9.Token(
+      context.chain.uniswapChainId,
+      evmAddress,
+      metadata.decimals ?? 6,
+      metadata.symbol,
+      metadata.name,
+      true
+    )
+  };
+}
+function parseLiquidityPercentageInput(value, label) {
+  if (value instanceof import_sun_sdk_core9.Percent) return value;
+  const match = PERCENT_PATTERN2.exec(value);
+  if (!match) {
+    throw new import_sun_sdk_core9.SDKError("SDK_INVALID_ARGUMENT", `${label} must be a percentage string`, {
+      label,
+      percentage: value
+    });
+  }
+  const whole = match[1] ?? "0";
+  const fraction = match[2] ?? "";
+  const scale = 10n ** BigInt(fraction.length);
+  const percentageUnits = BigInt(whole) * scale + BigInt(fraction || "0");
+  return new import_sun_sdk_core9.Percent(percentageUnits.toString(), (100n * scale).toString());
+}
+function normalizeLiquidityPercentage(value, label) {
+  const percent = parseLiquidityPercentageInput(value, label);
+  if (percent.equalTo(0)) {
+    throw new import_sun_sdk_core9.SDKError("SDK_INVALID_ARGUMENT", `${label} must be greater than 0%`, {
+      label,
+      percentage: percent.toSignificant()
+    });
+  }
+  if (percent.greaterThan(1)) {
+    throw new import_sun_sdk_core9.SDKError("SDK_INVALID_ARGUMENT", `${label} must be at most 100%`, {
+      label,
+      percentage: percent.toSignificant()
+    });
+  }
+  return percent;
+}
+
+// src/internal/intents.ts
+function attachApprovalIntent(actions, scope, tokenSymbol) {
+  const intent = { kind: "approve", scope, tokenSymbol };
+  return actions.map((action) => action.execute === "runtime" ? { ...action, intent } : action);
+}
+
+// src/liquidity/intents.ts
+var SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID = "sunswap-v2";
+var SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID = "sunswap-v3";
+var SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID = "sunswap-v4";
+function liquidityIntentScope(protocol, operation) {
+  return { domain: "liquidity", protocol, operation };
+}
+
+// src/liquidity/v2.ts
+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 import_sun_sdk_core10.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 import_sun_sdk_core10.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 import_sun_sdk_core10.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) : (0, import_sun_sdk_core10.assertTronAddress)(normalized, label);
+  } catch {
+    throw new import_sun_sdk_core10.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 import_sun_sdk_core10.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: (0, import_sun_sdk_sunswap_v22.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 import_sun_sdk_core10.SDKError("SDK_CONTRACT_ERROR", "V2 pair reserves result is malformed", { result });
+  }
+  let normalized;
+  try {
+    normalized = (0, import_sun_sdk_sunswap_v22.normalizeV2ReserveResult)(result);
+  } catch {
+    throw new import_sun_sdk_core10.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 import_sun_sdk_core10.SDKError("SDK_CONTRACT_ERROR", "V2 pair has inconsistent zero reserves", {
+      reserveA: input.reserves.reserveA,
+      reserveB: input.reserves.reserveB
+    });
+  }
+  const amountBOptimal = (0, import_sun_sdk_sunswap_v22.quoteV2LiquidityAmount)(
+    input.amountADesired,
+    input.reserves.reserveA,
+    input.reserves.reserveB
+  );
+  if (BigInt(amountBOptimal) <= BigInt(input.amountBDesired)) {
+    return { amountA: input.amountADesired, amountB: amountBOptimal };
+  }
+  const amountAOptimal = (0, import_sun_sdk_sunswap_v22.quoteV2LiquidityAmount)(
+    input.amountBDesired,
+    input.reserves.reserveB,
+    input.reserves.reserveA
+  );
+  if (BigInt(amountAOptimal) > BigInt(input.amountADesired)) {
+    throw new import_sun_sdk_core10.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 import_sun_sdk_sunswap_v22.Pair(
+    import_sun_sdk_core10.CurrencyAmount.fromRawAmount(pair.tokenA.token, reserves.reserveA),
+    import_sun_sdk_core10.CurrencyAmount.fromRawAmount(pair.tokenB.token, reserves.reserveB)
+  );
+}
+function validateAddAmounts(pair, reserves, amounts) {
+  if (BigInt(amounts.amountA) === 0n || BigInt(amounts.amountB) === 0n) {
+    throw new import_sun_sdk_core10.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(
+      import_sun_sdk_core10.CurrencyAmount.fromRawAmount(pairEntity.liquidityToken, "0"),
+      import_sun_sdk_core10.CurrencyAmount.fromRawAmount(pair.tokenA.token, amounts.amountA),
+      import_sun_sdk_core10.CurrencyAmount.fromRawAmount(pair.tokenB.token, amounts.amountB)
+    );
+  } catch {
+    throw new import_sun_sdk_core10.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" ? (0, import_sun_sdk_sunswap_v22.buildV2AddLiquidityEthAction)({
+    ...options,
+    token: input.pair.tokenB.token,
+    amountTokenDesired: input.amountB,
+    amountEthDesired: input.amountA,
+    amountTokenMin: input.amountBMin,
+    amountEthMin: input.amountAMin
+  }) : input.pair.tokenB.kind === "native" ? (0, import_sun_sdk_sunswap_v22.buildV2AddLiquidityEthAction)({
+    ...options,
+    token: input.pair.tokenA.token,
+    amountTokenDesired: input.amountA,
+    amountEthDesired: input.amountB,
+    amountTokenMin: input.amountAMin,
+    amountEthMin: input.amountBMin
+  }) : (0, import_sun_sdk_sunswap_v22.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 = (0, import_sun_sdk_sunswap_v22.buildV2RemoveLiquidityEthAction)({
+      ...options,
+      token: input.pair.tokenB.token,
+      amountTokenMin: input.amountBMin,
+      amountEthMin: input.amountAMin
+    });
+  } else if (input.pair.tokenB.kind === "native") {
+    action = (0, import_sun_sdk_sunswap_v22.buildV2RemoveLiquidityEthAction)({
+      ...options,
+      token: input.pair.tokenA.token,
+      amountTokenMin: input.amountAMin,
+      amountEthMin: input.amountBMin
+    });
+  } else {
+    action = (0, import_sun_sdk_sunswap_v22.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 import_sun_sdk_core10.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 import_sun_sdk_core10.SDKError("SDK_INVALID_ARGUMENT", "percentage resolves to zero liquidity", {
+        balance,
+        percentage: percentage.toSignificant()
+      });
+    }
+    return result;
+  })();
+  if (liquidity > BigInt(balance)) {
+    throw new import_sun_sdk_core10.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,
+    (0, import_sun_sdk_sunswap_v22.buildV2FactoryPairRead)({
+      network: context.network,
+      tokenA: pair.tokenAContract,
+      tokenB: pair.tokenBContract
+    }),
+    "V2 add liquidity pair lookup"
+  ), "V2 factory pair");
+  if (deployedPair !== import_sun_sdk_core10.TRON_ZERO_ADDRESS && deployedPair !== pair.pair) {
+    throw new import_sun_sdk_core10.SDKError("SDK_CONTRACT_ERROR", "V2 factory pair does not match the configured CREATE2 pair", {
+      factoryPair: deployedPair,
+      computedPair: pair.pair
+    });
+  }
+  const reserves = deployedPair === import_sun_sdk_core10.TRON_ZERO_ADDRESS ? { reserveA: "0", reserveB: "0" } : parsePairReserves(await readRequiredContract(
+    context,
+    (0, import_sun_sdk_sunswap_v22.buildV2PairReservesRead)(pair.pair),
+    "V2 add liquidity reserves"
+  ), pair.tokenASortsBefore);
+  const amounts = resolveAddAmounts({ amountADesired, amountBDesired, reserves });
+  validateAddAmounts(pair, reserves, amounts);
+  const slippageMinimums = (0, import_sun_sdk_sunswap_v22.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 import_sun_sdk_core10.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,
+    [
+      (0, import_sun_sdk_sunswap_v22.buildV2PairReservesRead)(pair.pair),
+      (0, import_sun_sdk_sunswap_v22.buildV2PairTotalSupplyRead)(pair.pair),
+      (0, import_sun_sdk_sunswap_v22.buildV2PairBalanceRead)(pair.pair, owner),
+      (0, import_sun_sdk_sunswap_v22.buildV2FactoryFeeToRead)({ network: context.network }),
+      (0, import_sun_sdk_sunswap_v22.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 !== import_sun_sdk_core10.TRON_ZERO_ADDRESS;
+  if (BigInt(totalSupply) === 0n) {
+    throw new import_sun_sdk_core10.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 import_sun_sdk_core10.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 import_sun_sdk_core10.SDKError("SDK_CONTRACT_ERROR", "V2 LP balance exceeds pair total supply", {
+      liquidity,
+      totalSupply
+    });
+  }
+  const pairEntity = createPairEntity(pair, reserves);
+  const totalSupplyAmount = import_sun_sdk_core10.CurrencyAmount.fromRawAmount(pairEntity.liquidityToken, totalSupply);
+  const liquidityAmount = import_sun_sdk_core10.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 import_sun_sdk_core10.SDKError("SDK_INVALID_ARGUMENT", "V2 remove liquidity resolves to a zero token amount", {
+      liquidity,
+      amountA,
+      amountB
+    });
+  }
+  const minimums = (0, import_sun_sdk_sunswap_v22.getV2RemoveLiquidityMinimums)({ amountA, amountB }, slippage);
+  const approvals = [];
+  if (approvalMode !== "none") {
+    const allowance = parseContractInteger(
+      await readRequiredContract(
+        context,
+        (0, import_sun_sdk_sunswap_v22.buildV2PairAllowanceRead)(pair.pair, owner, router),
+        "V2 LP allowance"
+      ),
+      "LP allowance"
+    );
+    if (BigInt(allowance) < BigInt(liquidity)) {
+      approvals.push({
+        ...(0, import_sun_sdk_sunswap_v22.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/v3.ts
+var import_sun_sdk_core12 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_sunswap_v3 = require("@sun-protocol/sun-sdk-sunswap-v3");
+
+// src/internal/method-parameters.ts
+var import_sun_sdk_core11 = require("@sun-protocol/sun-sdk-core");
+function methodParametersToAction(input) {
+  return (0, import_sun_sdk_core11.createContractCallAction)({
+    id: input.id,
+    target: input.target,
+    functionSelector: input.methodParameters.function_selector,
+    parameters: input.methodParameters.parameter,
+    callValue: BigInt(input.methodParameters.value),
+    ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+    ...input.waitForReceipt !== void 0 ? { waitForReceipt: input.waitForReceipt } : {},
+    ...input.metadata !== void 0 ? { metadata: input.metadata } : {},
+    ...input.intent !== void 0 ? { intent: input.intent } : {}
+  });
+}
+
+// src/liquidity/v3.ts
+function integerString(value, label) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    return BigInt(value.toString()).toString();
+  }
+  throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+}
+function integerNumber(value, label) {
+  const parsed = Number(integerString(value, label));
+  if (!Number.isSafeInteger(parsed)) {
+    throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", `${label} must be a safe integer`, { value });
+  }
+  return parsed;
+}
+function positionToken(value, label) {
+  if (typeof value !== "string") {
+    throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", `${label} must be an address string`, { value });
+  }
+  if (value.startsWith("0x")) return evmHexToTronAddress(value, label);
+  if (/^41[0-9a-fA-F]{40}$/.test(value)) {
+    return evmHexToTronAddress(`0x${value.slice(2)}`, label);
+  }
+  return (0, import_sun_sdk_core12.assertTronAddress)(value, label);
+}
+function parseV3Slot0(result) {
+  if (Array.isArray(result)) {
+    return {
+      sqrtRatioX96: integerString(result[0], "sqrtRatioX96"),
+      tickCurrent: integerNumber(result[1], "tickCurrent")
+    };
+  }
+  if (typeof result === "object" && result !== null) {
+    const slot0 = result;
+    return {
+      sqrtRatioX96: integerString(slot0.sqrtPriceX96 ?? slot0.sqrtRatioX96, "sqrtRatioX96"),
+      tickCurrent: integerNumber(slot0.tick, "tickCurrent")
+    };
+  }
+  throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", "V3 slot0 result is malformed", { result });
+}
+async function resolveV3PoolState(context, input) {
+  const tokenA = normalizeProtocolToken(context, input.tokenA, "tokenA");
+  const tokenB = normalizeProtocolToken(context, input.tokenB, "tokenB");
+  const poolAddress = (0, import_sun_sdk_sunswap_v3.computeV3PoolAddress)({
+    network: context.network,
+    tokenA: tokenA.contractAddress,
+    tokenB: tokenB.contractAddress,
+    fee: input.fee,
+    factory: resolveProtocolContract(context, input.contracts, "sunswapV3Factory")
+  });
+  const [slot0Result, liquidityResult, feeResult, tickSpacingResult] = await readMulticallRequired(
+    context,
+    (0, import_sun_sdk_sunswap_v3.buildV3PoolStateReads)({ pool: poolAddress }),
+    "V3 pool state read"
+  );
+  const fee = integerNumber(feeResult, "fee");
+  if (fee !== input.fee) {
+    throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", "V3 pool fee does not match requested fee", {
+      pool: poolAddress,
+      requestedFee: input.fee,
+      poolFee: fee
+    });
+  }
+  const slot0 = parseV3Slot0(slot0Result);
+  return {
+    sqrtRatioX96: slot0.sqrtRatioX96,
+    liquidity: integerString(liquidityResult, "liquidity"),
+    tickCurrent: slot0.tickCurrent,
+    tickSpacing: integerNumber(tickSpacingResult, "tickSpacing")
+  };
+}
+async function resolveV3PositionContext(context, tokenId, contracts) {
+  const result = await readRequiredContract(
+    context,
+    (0, import_sun_sdk_sunswap_v3.buildV3PositionRead)({
+      network: context.network,
+      tokenId,
+      positionManager: resolveProtocolContract(context, contracts, "sunswapV3PositionManager")
+    }),
+    "V3 position context read"
+  );
+  let token0;
+  let token1;
+  let fee;
+  let tickLower;
+  let tickUpper;
+  if (Array.isArray(result)) {
+    token0 = result[2];
+    token1 = result[3];
+    fee = result[4];
+    tickLower = result[5];
+    tickUpper = result[6];
+  } else if (typeof result === "object" && result !== null) {
+    const position = result;
+    token0 = position.token0;
+    token1 = position.token1;
+    fee = position.fee;
+    tickLower = position.tickLower;
+    tickUpper = position.tickUpper;
+  } else {
+    throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", "V3 position result is malformed", { result });
+  }
+  return {
+    tokenA: positionToken(token0, "token0"),
+    tokenB: positionToken(token1, "token1"),
+    fee: integerNumber(fee, "fee"),
+    tickLower: integerNumber(tickLower, "tickLower"),
+    tickUpper: integerNumber(tickUpper, "tickUpper")
+  };
+}
+function normalizeSingleSideAmounts(input) {
+  if (input.amount0 === void 0 && input.amount1 === void 0) {
+    throw new import_sun_sdk_core12.SDKError("SDK_INVALID_ARGUMENT", "V3 liquidity requires at least one of amount0 or amount1");
+  }
+  return {
+    amount0: input.amount0 ?? "0",
+    amount1: input.amount1 ?? "0"
+  };
+}
+function assertV3PositionContextMatches(context, tokenId, input, position) {
+  const mismatches = {};
+  const suppliedTokenA = input.tokenA === void 0 ? void 0 : normalizeV3ContextToken(context, input.tokenA, "tokenA");
+  const suppliedTokenB = input.tokenB === void 0 ? void 0 : normalizeV3ContextToken(context, input.tokenB, "tokenB");
+  const positionTokens = [position.tokenA, position.tokenB];
+  if (suppliedTokenA !== void 0 && suppliedTokenB !== void 0) {
+    const pairMatches = suppliedTokenA === position.tokenA && suppliedTokenB === position.tokenB || suppliedTokenA === position.tokenB && suppliedTokenB === position.tokenA;
+    if (!pairMatches) {
+      mismatches.tokens = { supplied: [suppliedTokenA, suppliedTokenB], position: positionTokens };
+    }
+  } else {
+    if (suppliedTokenA !== void 0 && !positionTokens.includes(suppliedTokenA)) {
+      mismatches.tokenA = { supplied: suppliedTokenA, position: positionTokens };
+    }
+    if (suppliedTokenB !== void 0 && !positionTokens.includes(suppliedTokenB)) {
+      mismatches.tokenB = { supplied: suppliedTokenB, position: positionTokens };
+    }
+  }
+  if (input.fee !== void 0 && input.fee !== position.fee) {
+    mismatches.fee = { supplied: input.fee, position: position.fee };
+  }
+  if (input.tickLower !== void 0 && input.tickLower !== position.tickLower) {
+    mismatches.tickLower = { supplied: input.tickLower, position: position.tickLower };
+  }
+  if (input.tickUpper !== void 0 && input.tickUpper !== position.tickUpper) {
+    mismatches.tickUpper = { supplied: input.tickUpper, position: position.tickUpper };
+  }
+  if (Object.keys(mismatches).length > 0) {
+    throw new import_sun_sdk_core12.SDKError("SDK_INVALID_ARGUMENT", "V3 increase context does not match the tokenId position", {
+      tokenId,
+      mismatches
+    });
+  }
+}
+function normalizeV3ContextToken(context, token, label) {
+  const normalized = normalizeProtocolToken(context, token, label);
+  return normalized.kind === "native" ? normalized.wrappedContractAddress : normalized.contractAddress;
+}
+function resolveTickRange(input) {
+  if (input.tickLower !== void 0 && input.tickUpper !== void 0) {
+    return { tickLower: input.tickLower, tickUpper: input.tickUpper, derived: false };
+  }
+  if (input.tickLower !== void 0 || input.tickUpper !== void 0) {
+    throw new import_sun_sdk_core12.SDKError("SDK_INVALID_ARGUMENT", "tickLower and tickUpper must be provided together");
+  }
+  if (!Number.isInteger(input.tickRangeWidth) || (input.tickRangeWidth ?? 0) <= 0) {
+    throw new import_sun_sdk_core12.SDKError("SDK_INVALID_ARGUMENT", "tickRangeWidth must be a positive integer when ticks are omitted", {
+      tickRangeWidth: input.tickRangeWidth
+    });
+  }
+  const tickSpacing = input.pool.tickSpacing;
+  if (tickSpacing === void 0) {
+    throw new import_sun_sdk_core12.SDKError("SDK_INVALID_ARGUMENT", "pool tickSpacing is required to derive a tick range");
+  }
+  const width = input.tickRangeWidth;
+  const lowerTarget = Math.max(import_sun_sdk_sunswap_v3.TickMath.MIN_TICK, input.pool.tickCurrent - width * tickSpacing);
+  const upperTarget = Math.min(import_sun_sdk_sunswap_v3.TickMath.MAX_TICK, input.pool.tickCurrent + width * tickSpacing);
+  let tickLower = (0, import_sun_sdk_sunswap_v3.nearestUsableTick)(lowerTarget, tickSpacing);
+  let tickUpper = (0, import_sun_sdk_sunswap_v3.nearestUsableTick)(upperTarget, tickSpacing);
+  if (tickUpper - tickLower < tickSpacing) {
+    const maxUsableTick = (0, import_sun_sdk_sunswap_v3.nearestUsableTick)(import_sun_sdk_sunswap_v3.TickMath.MAX_TICK, tickSpacing);
+    if (tickUpper < maxUsableTick) tickUpper += tickSpacing;
+    else tickLower -= tickSpacing;
+  }
+  return {
+    tickLower,
+    tickUpper,
+    derived: true
+  };
+}
+function createPool(input) {
+  const tokenA = normalizeProtocolToken(input.context, input.tokenA, "tokenA");
+  const tokenB = normalizeProtocolToken(input.context, input.tokenB, "tokenB");
+  return {
+    tokenA,
+    tokenB,
+    pool: new import_sun_sdk_sunswap_v3.Pool({
+      tokenA: tokenA.token,
+      tokenB: tokenB.token,
+      fee: input.fee,
+      sqrtRatioX96: normalizeBaseUnitAmount(input.pool.sqrtRatioX96, "sqrtRatioX96"),
+      liquidity: normalizeBaseUnitAmount(input.pool.liquidity, "pool liquidity", { allowZero: true }),
+      tickCurrent: input.pool.tickCurrent,
+      ...input.pool.tickSpacing !== void 0 ? { tickSpacing: input.pool.tickSpacing } : {}
+    })
+  };
+}
+function createPosition(input) {
+  return import_sun_sdk_sunswap_v3.Position.fromAmounts({
+    pool: input.pool,
+    tickLower: input.tickLower,
+    tickUpper: input.tickUpper,
+    amount0: input.amount0,
+    amount1: input.amount1,
+    useFullPrecision: input.useFullPrecision ?? true
+  });
+}
+function isNativePoolToken(poolToken, tokenA, tokenB) {
+  return tokenA.kind === "native" && poolToken.equals(tokenA.token) || tokenB.kind === "native" && poolToken.equals(tokenB.token);
+}
+async function planTokenApproval2(input) {
+  if (isNativePoolToken(input.token, input.tokenA, input.tokenB)) return [];
+  if (BigInt(input.amount) === 0n) return [];
+  const approval = await planApproval(
+    input.context,
+    {
+      asset: { type: "token", token: evmHexToTronAddress(input.token.address) },
+      owner: input.owner,
+      spender: input.spender,
+      amount: input.amount
+    },
+    { mode: input.approval ?? "auto" }
+  );
+  return attachApprovalIntent(
+    approval.actions,
+    liquidityIntentScope(SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID, input.operation),
+    input.token.symbol ?? input.token.address
+  );
+}
+function amountForToken(position, token) {
+  if (position.pool.token0.equals(token)) return position.mintAmounts.amount0.toString();
+  return position.mintAmounts.amount1.toString();
+}
+function applyExplicitAddMinimums(methodParameters, amount0Min, amount1Min) {
+  const parameter = methodParameters.parameter[0];
+  const mintSelector = import_sun_sdk_sunswap_v3.NonfungiblePositionManager.INTERFACE.getSighash("mint");
+  const calldatas = parameter.value.map((calldata) => {
+    if (!calldata.startsWith(mintSelector)) return calldata;
+    const [mint] = import_sun_sdk_sunswap_v3.NonfungiblePositionManager.INTERFACE.decodeFunctionData("mint", calldata);
+    return import_sun_sdk_sunswap_v3.NonfungiblePositionManager.INTERFACE.encodeFunctionData("mint", [{
+      token0: mint.token0,
+      token1: mint.token1,
+      fee: mint.fee,
+      tickLower: mint.tickLower,
+      tickUpper: mint.tickUpper,
+      amount0Desired: mint.amount0Desired,
+      amount1Desired: mint.amount1Desired,
+      amount0Min,
+      amount1Min,
+      recipient: mint.recipient,
+      deadline: mint.deadline
+    }]);
+  });
+  return {
+    ...methodParameters,
+    calldata: import_sun_sdk_sunswap_v3.Multicall.encodeMulticall(calldatas),
+    parameter: [{ type: "bytes[]", value: calldatas }]
+  };
+}
+var V3LiquidityClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  add = {
+    plan: async (input) => this.planAdd(input),
+    execute: async (input) => executeTransactionPlan(await this.planAdd(input), createContextExecutor(this.context))
+  };
+  increase = {
+    plan: async (input) => this.planIncrease(input),
+    execute: async (input) => executeTransactionPlan(await this.planIncrease(input), createContextExecutor(this.context))
+  };
+  async planAdd(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager");
+    const planId = nextPlanId(this.context, "liquidity-v3-add");
+    const owner = await requireWalletAddress(this.context, "V3 add liquidity");
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V3 add liquidity", owner);
+    const deadline = normalizeDeadline(this.context, input);
+    const amounts = normalizeSingleSideAmounts(input);
+    const amount0 = normalizeBaseUnitAmount(amounts.amount0, "amount0", { allowZero: true });
+    const amount1 = normalizeBaseUnitAmount(amounts.amount1, "amount1", { allowZero: true });
+    const poolDerived = input.pool === void 0;
+    const poolState = input.pool ?? await resolveV3PoolState(this.context, input);
+    const tickRange = resolveTickRange({
+      ...input.tickLower !== void 0 ? { tickLower: input.tickLower } : {},
+      ...input.tickUpper !== void 0 ? { tickUpper: input.tickUpper } : {},
+      ...input.tickRangeWidth !== void 0 ? { tickRangeWidth: input.tickRangeWidth } : {},
+      pool: poolState
+    });
+    const { pool, tokenA, tokenB } = createPool({
+      context: this.context,
+      tokenA: input.tokenA,
+      tokenB: input.tokenB,
+      fee: input.fee,
+      pool: poolState
+    });
+    const position = createPosition({
+      pool,
+      tickLower: tickRange.tickLower,
+      tickUpper: tickRange.tickUpper,
+      amount0,
+      amount1,
+      ...input.useFullPrecision !== void 0 ? { useFullPrecision: input.useFullPrecision } : {}
+    });
+    const slippageTolerance = parseSlippage(input.slippage ?? "0.5%");
+    const slippageMinimums = position.mintAmountsWithSlippage(slippageTolerance);
+    const amount0Min = input.amount0Min === void 0 ? slippageMinimums.amount0.toString() : normalizeBaseUnitAmount(input.amount0Min, "amount0Min", { allowZero: true });
+    const amount1Min = input.amount1Min === void 0 ? slippageMinimums.amount1.toString() : normalizeBaseUnitAmount(input.amount1Min, "amount1Min", { allowZero: true });
+    const generatedMethodParameters = import_sun_sdk_sunswap_v3.NonfungiblePositionManager.addCallParameters(position, {
+      recipient: tronAddressToEvmAddress(recipient, "recipient"),
+      ...input.createPool !== void 0 ? { createPool: input.createPool } : {},
+      slippageTolerance,
+      deadline,
+      ...tokenA.kind === "native" || tokenB.kind === "native" ? { useNative: this.context.chain.nativeCurrency } : {}
+    });
+    const methodParameters = input.amount0Min === void 0 && input.amount1Min === void 0 ? generatedMethodParameters : applyExplicitAddMinimums(generatedMethodParameters, amount0Min, amount1Min);
+    const action = methodParametersToAction({
+      id: `${planId}-tx`,
+      target: positionManager,
+      methodParameters,
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      waitForReceipt: "included",
+      intent: {
+        kind: "add-liquidity",
+        scope: liquidityIntentScope(SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID, "add-liquidity")
+      }
+    });
+    const approvals = [
+      ...await planTokenApproval2({
+        context: this.context,
+        owner,
+        token: pool.token0,
+        amount: amountForToken(position, pool.token0),
+        spender: positionManager,
+        approval: input.approval,
+        tokenA,
+        tokenB,
+        operation: "add-liquidity"
+      }),
+      ...await planTokenApproval2({
+        context: this.context,
+        owner,
+        token: pool.token1,
+        amount: amountForToken(position, pool.token1),
+        spender: positionManager,
+        approval: input.approval,
+        tokenA,
+        tokenB,
+        operation: "add-liquidity"
+      })
+    ];
+    return {
+      id: planId,
+      kind: "liquidity",
+      network: this.context.network,
+      owner,
+      summary: { title: "Add SunSwap V3 liquidity", lines: [`Recipient ${recipient}`] },
+      approvals,
+      transactions: [action],
+      metadata: {
+        protocol: "sunswap-v3",
+        operation: "add-liquidity",
+        recipient,
+        deadline,
+        slippageBips: slippageToBips(input.slippage ?? "0.5%"),
+        poolDerived,
+        tickRangeDerived: tickRange.derived,
+        tickLower: tickRange.tickLower,
+        tickUpper: tickRange.tickUpper
+      }
+    };
+  }
+  async planIncrease(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager");
+    const planId = nextPlanId(this.context, "liquidity-v3-increase");
+    const owner = await requireWalletAddress(this.context, "V3 increase liquidity");
+    const deadline = normalizeDeadline(this.context, input);
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const amounts = normalizeSingleSideAmounts(input);
+    const amount0 = normalizeBaseUnitAmount(amounts.amount0, "amount0", { allowZero: true });
+    const amount1 = normalizeBaseUnitAmount(amounts.amount1, "amount1", { allowZero: true });
+    const positionDerived = input.tokenA === void 0 || input.tokenB === void 0 || input.fee === void 0 || input.tickLower === void 0 || input.tickUpper === void 0;
+    const positionContext = await resolveV3PositionContext(this.context, tokenId, input.contracts);
+    assertV3PositionContextMatches(this.context, tokenId, input, positionContext);
+    const tokenAInput = input.tokenA ?? positionContext.tokenA;
+    const tokenBInput = input.tokenB ?? positionContext.tokenB;
+    const fee = input.fee ?? positionContext.fee;
+    const tickLower = input.tickLower ?? positionContext.tickLower;
+    const tickUpper = input.tickUpper ?? positionContext.tickUpper;
+    if (tokenAInput === void 0 || tokenBInput === void 0 || fee === void 0 || tickLower === void 0 || tickUpper === void 0) {
+      throw new import_sun_sdk_core12.SDKError("SDK_CONTRACT_ERROR", "V3 position context is incomplete", { tokenId });
+    }
+    const poolDerived = input.pool === void 0;
+    const poolState = input.pool ?? await resolveV3PoolState(this.context, {
+      tokenA: tokenAInput,
+      tokenB: tokenBInput,
+      fee,
+      contracts: input.contracts
+    });
+    const { pool, tokenA, tokenB } = createPool({
+      context: this.context,
+      tokenA: tokenAInput,
+      tokenB: tokenBInput,
+      fee,
+      pool: poolState
+    });
+    const position = createPosition({
+      pool,
+      tickLower,
+      tickUpper,
+      amount0,
+      amount1,
+      ...input.useFullPrecision !== void 0 ? { useFullPrecision: input.useFullPrecision } : {}
+    });
+    const methodParameters = import_sun_sdk_sunswap_v3.NonfungiblePositionManager.addCallParameters(position, {
+      tokenId,
+      slippageTolerance: parseSlippage(input.slippage ?? "0.5%"),
+      deadline,
+      ...tokenA.kind === "native" || tokenB.kind === "native" ? { useNative: this.context.chain.nativeCurrency } : {}
+    });
+    const action = methodParametersToAction({
+      id: `${planId}-tx`,
+      target: positionManager,
+      methodParameters,
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      waitForReceipt: "included",
+      intent: {
+        kind: "add-liquidity",
+        scope: liquidityIntentScope(SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID, "increase-liquidity"),
+        positionId: tokenId
+      }
+    });
+    const approvals = [
+      ...await planTokenApproval2({
+        context: this.context,
+        owner,
+        token: pool.token0,
+        amount: amountForToken(position, pool.token0),
+        spender: positionManager,
+        approval: input.approval,
+        tokenA,
+        tokenB,
+        operation: "increase-liquidity"
+      }),
+      ...await planTokenApproval2({
+        context: this.context,
+        owner,
+        token: pool.token1,
+        amount: amountForToken(position, pool.token1),
+        spender: positionManager,
+        approval: input.approval,
+        tokenA,
+        tokenB,
+        operation: "increase-liquidity"
+      })
+    ];
+    return {
+      id: planId,
+      kind: "liquidity",
+      network: this.context.network,
+      owner,
+      summary: { title: "Increase SunSwap V3 liquidity", lines: [`Position ${tokenId}`] },
+      approvals,
+      transactions: [action],
+      metadata: {
+        protocol: "sunswap-v3",
+        operation: "increase-liquidity",
+        tokenId,
+        deadline,
+        slippageBips: slippageToBips(input.slippage ?? "0.5%"),
+        positionDerived,
+        poolDerived
+      }
+    };
+  }
+};
+
+// src/liquidity/v4.ts
+var import_sun_sdk_core15 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_sunswap_v32 = require("@sun-protocol/sun-sdk-sunswap-v3");
+var import_sun_sdk_sunswap_v4 = require("@sun-protocol/sun-sdk-sunswap-v4");
+
+// src/approval/permit2.ts
+var import_sun_sdk_core14 = require("@sun-protocol/sun-sdk-core");
+
+// src/internal/permit2-adapter.ts
+var import_sun_sdk_core13 = require("@sun-protocol/sun-sdk-core");
+var import_permit2_sdk = require("@sun-protocol/permit2-sdk");
+var PERMIT2_TYPED_DATA_CHAIN_IDS = {
+  mainnet: 728126428,
+  nile: 3448148188
+};
+function buildPermit2HelperRead(input) {
+  return {
+    target: input.helper,
+    functionSelector: "checkPermit2Allowance(address,address,address,address,uint256)",
+    parameters: [
+      { type: "address", value: input.permit2 },
+      { type: "address", value: input.token },
+      { type: "address", value: input.owner },
+      { type: "address", value: input.spender },
+      { type: "uint256", value: input.amount }
+    ],
+    outputs: [{ type: "bool", name: "approved" }]
+  };
+}
+function normalizePermit2HelperResult(result) {
+  if (typeof result === "boolean") return result;
+  if (Array.isArray(result) && result.length === 1 && typeof result[0] === "boolean") return result[0];
+  throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", "Invalid Permit2Helper approval result", { result });
+}
+function buildPermit2AllowanceRead(input) {
+  return {
+    target: input.permit2,
+    functionSelector: "allowance(address,address,address)",
+    parameters: [
+      { type: "address", value: input.owner },
+      { type: "address", value: input.token },
+      { type: "address", value: input.spender }
+    ],
+    outputs: [
+      { type: "uint160", name: "amount" },
+      { type: "uint48", name: "expiration" },
+      { type: "uint48", name: "nonce" }
+    ]
+  };
+}
+function bigintFrom(value, label) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+  if (typeof value === "string" && /^[0-9]+$/.test(value)) return BigInt(value);
+  throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", `Invalid Permit2 allowance ${label}`, { value });
+}
+function normalizePermit2Allowance(result) {
+  if (Array.isArray(result)) {
+    return {
+      amount: bigintFrom(result[0], "amount"),
+      expiration: bigintFrom(result[1], "expiration"),
+      nonce: bigintFrom(result[2], "nonce")
+    };
+  }
+  if (typeof result === "object" && result !== null) {
+    const value = result;
+    return {
+      amount: bigintFrom(value.amount ?? value[0], "amount"),
+      expiration: bigintFrom(value.expiration ?? value[1], "expiration"),
+      nonce: bigintFrom(value.nonce ?? value[2], "nonce")
+    };
+  }
+  throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", "Invalid Permit2 allowance result", { result });
+}
+function buildPermit2TypedData(input) {
+  return {
+    primaryType: "PermitSingle",
+    domain: {
+      name: "Permit2",
+      chainId: PERMIT2_TYPED_DATA_CHAIN_IDS[input.network],
+      verifyingContract: (0, import_permit2_sdk.toEvmHex)(input.permit2)
+    },
+    types: import_permit2_sdk.PERMIT_TYPES,
+    message: {
+      details: {
+        token: (0, import_permit2_sdk.toEvmHex)(input.token),
+        amount: input.amount,
+        expiration: input.expiration,
+        nonce: input.nonce
+      },
+      spender: (0, import_permit2_sdk.toEvmHex)(input.spender),
+      sigDeadline: input.sigDeadline
+    }
+  };
+}
+function buildPermit2ApproveAction(input) {
+  return (0, import_sun_sdk_core13.createContractCallAction)({
+    id: input.id,
+    target: input.permit2,
+    functionSelector: "approve(address,address,uint160,uint48)",
+    waitForReceipt: "included",
+    parameters: [
+      { type: "address", value: input.token },
+      { type: "address", value: input.spender },
+      { type: "uint160", value: input.amount },
+      { type: "uint48", value: input.expiration }
+    ]
+  });
+}
+
+// src/approval/permit2.ts
+async function hasTypedDataCapability(context, capabilities) {
+  if (capabilities) return capabilities.signTypedData;
+  return (await context.runtime?.getWallet())?.capabilities.signTypedData === true;
+}
+function normalizePlanDeadlineValue(value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+var MAX_UINT160 = "1461501637330902918203684832716283019655932542975";
+async function planRouterPermit2Authorization(context, input) {
+  if (input.approval === "none") {
+    return { actions: [], mode: "none" };
+  }
+  const helper = context.chain.contracts.permit2Helper;
+  if (!helper) {
+    throw new import_sun_sdk_core14.SDKError("SDK_INVALID_ARGUMENT", `Permit2Helper is not configured for ${context.network}`, {
+      network: context.network,
+      contract: "permit2Helper"
+    });
+  }
+  const runtime = requireRuntime(context, "Router Permit2 authorization");
+  const actions = [];
+  const token = (0, import_sun_sdk_core14.assertTronAddress)(input.token, "token");
+  const spender = input.spender ? (0, import_sun_sdk_core14.assertTronAddress)(input.spender, "spender") : context.chain.contracts.universalRouter;
+  const tokenApproval = await planApproval(context, {
+    asset: { type: "token", token },
+    owner: input.owner,
+    spender: context.chain.contracts.permit2,
+    amount: input.amount
+  }, {
+    mode: "auto",
+    amount: input.approveAmountType ?? "exact"
+  });
+  actions.push(...tokenApproval.actions);
+  const approved = normalizePermit2HelperResult(await runtime.readContract(buildPermit2HelperRead({
+    helper,
+    permit2: context.chain.contracts.permit2,
+    owner: input.owner,
+    token,
+    spender,
+    amount: input.amount
+  })));
+  const permit2Amount = input.approveAmountType === "max" ? MAX_UINT160 : input.amount;
+  if (approved) {
+    return { actions, mode: "already-approved" };
+  }
+  const expiration = normalizeDeadline(context, {
+    ttlSeconds: input.ttlSeconds ?? 30 * 24 * 60 * 60,
+    ...input.deadline !== void 0 ? { deadline: normalizePlanDeadlineValue(input.deadline) } : {}
+  }).toString();
+  const sigDeadline = normalizeDeadline(context, { ttlSeconds: 3600 }).toString();
+  if ((input.approval === "auto" || input.approval === "permit2") && await hasTypedDataCapability(context, input.walletCapabilities)) {
+    const allowance = normalizePermit2Allowance(await runtime.readContract(buildPermit2AllowanceRead({
+      permit2: context.chain.contracts.permit2,
+      owner: input.owner,
+      token,
+      spender
+    })));
+    const typedData = buildPermit2TypedData({
+      network: context.network,
+      permit2: context.chain.contracts.permit2,
+      owner: input.owner,
+      token,
+      spender,
+      amount: permit2Amount,
+      expiration,
+      sigDeadline,
+      nonce: allowance.nonce.toString()
+    });
+    const signatureActionId = `${nextPlanId(context, "permit2")}-signature`;
+    actions.push((0, import_sun_sdk_core14.createTypedDataSignatureAction)({
+      id: signatureActionId,
+      typedData
+    }));
+    return {
+      actions,
+      signatureActionId,
+      permitSingle: typedData.message,
+      mode: "typed-data"
+    };
+  }
+  if (input.approval === "permit2" || input.approval === "auto" || input.approval === "approve") {
+    actions.push(buildPermit2ApproveAction({
+      id: `${nextPlanId(context, "permit2")}-approve`,
+      permit2: context.chain.contracts.permit2,
+      token,
+      spender,
+      amount: permit2Amount,
+      expiration
+    }));
+    return { actions, mode: "on-chain" };
+  }
+  throw new import_sun_sdk_core14.SDKError(
+    "SDK_INVALID_ARGUMENT",
+    "Unsupported approval mode for Router Permit2 authorization",
+    { approval: input.approval }
+  );
+}
+
+// src/liquidity/v4.ts
+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 import_sun_sdk_core15.SDKError("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 import_sun_sdk_core15.SDKError("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 (0, import_sun_sdk_core15.assertTronAddress)(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 (0, import_sun_sdk_sunswap_v4.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 (0, import_sun_sdk_sunswap_v4.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 import_sun_sdk_core15.SDKError("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 import_sun_sdk_core15.SDKError("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 import_sun_sdk_core15.SDKError("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 = (0, import_sun_sdk_core15.assertTronAddress)(input.hooks ?? import_sun_sdk_core15.TRON_ZERO_ADDRESS, "hooks");
+  if (input.dynamicFee && hooks === import_sun_sdk_core15.TRON_ZERO_ADDRESS) {
+    throw new import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "Dynamic V4 fees require a non-zero hooks contract");
+  }
+  const hooksRegistration = input.hooksRegistration ?? (hooks === import_sun_sdk_core15.TRON_ZERO_ADDRESS ? 0 : parseNumber(
+    unwrapSingle(await readRequiredContract(
+      context,
+      (0, import_sun_sdk_sunswap_v4.buildV4HookRegistrationBitmapRead)({ network: context.network, hooks }),
+      "V4 hook registration read"
+    )),
+    "hooksRegistration"
+  ));
+  const poolKey = (0, import_sun_sdk_sunswap_v4.createV4PoolKey)({
+    network: context.network,
+    currencyA: token0,
+    currencyB: token1,
+    hooks,
+    fee: input.dynamicFee ? 8388608 : input.fee,
+    parameters: (0, import_sun_sdk_sunswap_v4.encodeV4PoolParameters)({
+      tickSpacing: input.tickSpacing,
+      hooksRegistration: (0, import_sun_sdk_sunswap_v4.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 import_sun_sdk_core15.SDKError("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 = (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(supplied);
+  const positionPoolId = (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(position);
+  if (suppliedPoolId !== positionPoolId) {
+    throw new import_sun_sdk_core15.SDKError("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,
+    (0, import_sun_sdk_sunswap_v4.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,
+      (0, import_sun_sdk_sunswap_v4.buildV4PoolSlot0Read)({
+        network: context.network,
+        poolId: (0, import_sun_sdk_sunswap_v4.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(import_sun_sdk_sunswap_v32.TickMath.getSqrtRatioAtTick(input.tickLower).toString());
+  let sqrtB = BigInt(import_sun_sdk_sunswap_v32.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 import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "sqrtPriceX96 is required when createPool is true");
+    }
+    return normalizeBaseUnitAmount(input.sqrtPriceX96, "sqrtPriceX96");
+  }
+  const slot0Result = await readRequiredContract(
+    context,
+    (0, import_sun_sdk_sunswap_v4.buildV4PoolSlot0Read)({
+      network: context.network,
+      poolId: (0, import_sun_sdk_sunswap_v4.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 import_sun_sdk_core15.SDKError("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 import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "V4 liquidity requires at least one of amount0 or amount1");
+  }
+  if (input.tickLower >= input.tickUpper) {
+    throw new import_sun_sdk_core15.SDKError("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 import_sun_sdk_core15.SDKError("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 === import_sun_sdk_core15.TRON_ZERO_ADDRESS) value += BigInt(amounts.amount0Desired);
+  if (poolKey.currency1 === import_sun_sdk_core15.TRON_ZERO_ADDRESS) 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 import_sun_sdk_core15.SDKError(
+          "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 = (0, import_sun_sdk_sunswap_v4.assertV4PoolId)(input.poolId);
+    const [slot0Result, liquidityResult] = await readMulticallRequired(
+      this.context,
+      (0, import_sun_sdk_sunswap_v4.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 = (0, import_sun_sdk_sunswap_v4.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 = (0, import_sun_sdk_sunswap_v4.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 ? (0, import_sun_sdk_core15.assertTronAddress)(input.owner, "owner") : walletAddress;
+    if (owner !== walletAddress) {
+      throw new import_sun_sdk_core15.SDKError("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 import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "sqrtPriceX96 is required when createPool is true");
+    }
+    const hasNativeCurrency = poolKey.poolKey.currency0 === import_sun_sdk_core15.TRON_ZERO_ADDRESS || poolKey.poolKey.currency1 === import_sun_sdk_core15.TRON_ZERO_ADDRESS;
+    const sweepRecipient = hasNativeCurrency ? input.sweepRecipient !== void 0 ? (0, import_sun_sdk_core15.assertTronAddress)(input.sweepRecipient, "sweepRecipient") : owner : void 0;
+    const desiredNativeCallValue = nativeCallValue(poolKey.poolKey, amounts, input.nativeCallValueMode);
+    const action = (0, import_sun_sdk_sunswap_v4.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 = (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(poolKey.poolKey);
+    const initializeAction = initialization.shouldInitialize ? (0, import_sun_sdk_sunswap_v4.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) => (0, import_sun_sdk_sunswap_v4.encodeV4Permit2ForwardCall)({ owner, permit })),
+      ...initializeAction ? [(0, import_sun_sdk_sunswap_v4.encodeV4ContractCallAction)(initializeAction)] : [],
+      (0, import_sun_sdk_sunswap_v4.encodeV4ContractCallAction)(action)
+    ];
+    const transactionAction = initializeAction || input.transactionMode === "multicall" || (input.permit2Signatures?.length ?? 0) > 0 ? (0, import_sun_sdk_sunswap_v4.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 === import_sun_sdk_core15.TRON_ZERO_ADDRESS || poolKey.poolKey.currency1 === import_sun_sdk_core15.TRON_ZERO_ADDRESS;
+    const sweepRecipient = hasNativeCurrency ? input.sweepRecipient !== void 0 ? (0, import_sun_sdk_core15.assertTronAddress)(input.sweepRecipient, "sweepRecipient") : owner : void 0;
+    const desiredNativeCallValue = nativeCallValue(poolKey.poolKey, amounts, input.nativeCallValueMode);
+    const action = (0, import_sun_sdk_sunswap_v4.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 = (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(poolKey.poolKey);
+    const permitCalls = (input.permit2Signatures ?? []).map((permit) => (0, import_sun_sdk_sunswap_v4.encodeV4Permit2ForwardCall)({ owner, permit }));
+    const transactionAction = input.transactionMode === "multicall" || permitCalls.length > 0 ? (0, import_sun_sdk_sunswap_v4.buildV4MulticallAction)({
+      network: this.context.network,
+      positionManager,
+      calls: [...permitCalls, (0, import_sun_sdk_sunswap_v4.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LiquidityClient,
+  SUNSWAP_V2_LIQUIDITY_PROTOCOL_ID,
+  SUNSWAP_V3_LIQUIDITY_PROTOCOL_ID,
+  SUNSWAP_V4_LIQUIDITY_PROTOCOL_ID,
+  V2LiquidityClient,
+  V3LiquidityClient,
+  V4LiquidityClient,
+  createLiquidityClient,
+  createV2LiquidityClient,
+  planV2AddLiquidity,
+  planV2RemoveLiquidity
+});
+//# sourceMappingURL=index.cjs.map