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

package/dist/positions/index.cjs

@@ -0,0 +1,1544 @@
+"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/positions/index.ts
+var positions_exports = {};
+__export(positions_exports, {
+  PositionsClient: () => PositionsClient,
+  SUNSWAP_V3_POSITION_PROTOCOL_ID: () => SUNSWAP_V3_POSITION_PROTOCOL_ID,
+  SUNSWAP_V4_POSITION_PROTOCOL_ID: () => SUNSWAP_V4_POSITION_PROTOCOL_ID,
+  V3PositionsClient: () => V3PositionsClient,
+  V4PositionsClient: () => V4PositionsClient,
+  assertV3PositionUsdtTransfer: () => assertV3PositionUsdtTransfer,
+  createPositionsClient: () => createPositionsClient,
+  createV3PositionsExecutor: () => createV3PositionsExecutor
+});
+module.exports = __toCommonJS(positions_exports);
+
+// src/positions/v3.ts
+var import_sun_sdk_core13 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_sunswap_v32 = require("@sun-protocol/sun-sdk-sunswap-v3");
+
+// 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 applySlippageMin(expected, slippageBips) {
+  return expected * BigInt(1e4 - slippageBips) / 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/execute-plan.ts
+var import_sun_sdk_core5 = require("@sun-protocol/sun-sdk-core");
+
+// src/errors.ts
+var import_sun_sdk_core4 = 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_core4.SDKError) return error;
+  const code = isWalletRejection(error) ? "SDK_WALLET_REJECTED" : fallbackCode;
+  return new import_sun_sdk_core4.SDKError(code, message, { ...context, cause: error });
+}
+function withExecutionContext(error, context) {
+  return new import_sun_sdk_core4.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_core5.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_core5.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_core5.SDKError(
+          "SDK_RUNTIME_ERROR",
+          `Runtime action ${action.id} materialized to unsupported type: ${action.type}`
+        );
+      }
+      if (!executor.sendAction) {
+        throw new import_sun_sdk_core5.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_core5.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_core5.SDKError("SDK_INVALID_ARGUMENT", `Action ${action.id} is missing typedData`);
+      }
+      if (!executor.signTypedData) {
+        throw new import_sun_sdk_core5.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_core5.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires an API executor`);
+      }
+      return { action, result: await executor.executeHttpAction(action) };
+    }
+    throw new import_sun_sdk_core5.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_core5.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_core5.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_core5.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_core5.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_core5.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/positions/execute.ts
+var import_sun_sdk_core8 = require("@sun-protocol/sun-sdk-core");
+
+// src/usdt-transfer.ts
+var import_sun_sdk_core7 = require("@sun-protocol/sun-sdk-core");
+
+// src/internal/tokens.ts
+var import_sun_sdk_chains2 = require("@sun-protocol/sun-sdk-chains");
+var import_sun_sdk_core6 = 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_core6.assertTronAddress)(address, label))}`;
+}
+function normalizeTronAddress(address, label = "address") {
+  if (/^41[0-9a-fA-F]{40}$/.test(address)) return evmHexToTronAddress(`0x${address.slice(2)}`, label);
+  if (/^0x[0-9a-fA-F]{40}$/.test(address)) return evmHexToTronAddress(address, label);
+  return evmHexToTronAddress(tronAddressToEvmAddress(address, label), label);
+}
+function normalizeProtocolToken(context, token, label, metadata2 = {}) {
+  const wrappedContractAddress = (0, import_sun_sdk_chains2.getWrappedNativeAddress)(context.network);
+  const kind = isNativeTrxInput(context, token) ? "native" : "token";
+  const contractAddress = kind === "native" ? import_sun_sdk_core6.TRON_ZERO_ADDRESS : (0, import_sun_sdk_core6.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_core6.Token(
+      context.chain.uniswapChainId,
+      evmAddress,
+      metadata2.decimals ?? 6,
+      metadata2.symbol,
+      metadata2.name,
+      true
+    )
+  };
+}
+function parseLiquidityPercentageInput(value, label) {
+  if (value instanceof import_sun_sdk_core6.Percent) return value;
+  const match = PERCENT_PATTERN2.exec(value);
+  if (!match) {
+    throw new import_sun_sdk_core6.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_core6.Percent(percentageUnits.toString(), (100n * scale).toString());
+}
+function normalizeLiquidityPercentage(value, label) {
+  const percent = parseLiquidityPercentageInput(value, label);
+  if (percent.equalTo(0)) {
+    throw new import_sun_sdk_core6.SDKError("SDK_INVALID_ARGUMENT", `${label} must be greater than 0%`, {
+      label,
+      percentage: percent.toSignificant()
+    });
+  }
+  if (percent.greaterThan(1)) {
+    throw new import_sun_sdk_core6.SDKError("SDK_INVALID_ARGUMENT", `${label} must be at most 100%`, {
+      label,
+      percentage: percent.toSignificant()
+    });
+  }
+  return percent;
+}
+
+// src/usdt-transfer.ts
+async function usdtValidateTransfer(input) {
+  if (input.transfersUsdt === false) return { status: "allowed" };
+  if (input.transfersUsdt !== true) return { status: "unknown", reason: "CHECK_FAILED" };
+  if (input.sources.length === 0) return { status: "unknown", reason: "MISSING_TRANSFER_SOURCE" };
+  try {
+    const paused = await input.reader.paused();
+    if (typeof paused !== "boolean") throw new Error("Invalid paused result");
+    if (paused) return { status: "blocked", reason: "USDT_PAUSED" };
+    const sources = /* @__PURE__ */ new Map();
+    for (const source of input.sources) {
+      const address = normalizeTronAddress(source.address);
+      sources.set(address, { ...source, address });
+    }
+    const checks = await Promise.all([...sources.values()].map(async (source) => {
+      const blacklisted = await input.reader.isBlackListed(source.address);
+      if (typeof blacklisted !== "boolean") throw new Error("Invalid blacklist result");
+      return { source, blacklisted };
+    }));
+    const blocked = checks.filter((check) => check.blacklisted).map((check) => check.source);
+    return blocked.length > 0 ? { status: "blocked", reason: "USDT_SOURCE_BLACKLISTED", sources: blocked } : { status: "allowed" };
+  } catch {
+    return { status: "unknown", reason: "CHECK_FAILED" };
+  }
+}
+function parseTransferContext(context, action) {
+  const data = action.metadata?.usdtTransfer;
+  if (!data) throw new Error("Missing USDT transfer context");
+  if (data.network !== context.network || typeof data.transfersUsdt !== "boolean" || !Array.isArray(data.sources)) {
+    throw new Error("Invalid USDT transfer context; rebuild the plan");
+  }
+  const sources = data.sources.map((source) => {
+    if (!source || typeof source.address !== "string" || source.role !== "v3-pool" && source.role !== "position-manager") {
+      throw new Error("Invalid USDT transfer source");
+    }
+    const address = normalizeTronAddress(source.address);
+    if (source.role === "position-manager" && address !== normalizeTronAddress(action.target)) {
+      throw new Error("USDT sweep source does not match the position manager");
+    }
+    return { address, role: source.role };
+  });
+  if (!data.transfersUsdt && sources.length > 0) throw new Error("Unexpected USDT sources");
+  return { network: context.network, transfersUsdt: data.transfersUsdt, sources };
+}
+function boolRead(target, name, address) {
+  return {
+    target,
+    functionSelector: name === "paused" ? "paused()" : "isBlackListed(address)",
+    parameters: address === void 0 ? [] : [{ type: "address", value: address }],
+    abiFunction: {
+      type: "function",
+      name,
+      stateMutability: "view",
+      inputs: name === "paused" ? [] : [{ name: "_user", type: "address" }],
+      outputs: [{ name: "", type: "bool" }]
+    }
+  };
+}
+async function assertUsdtTransfer(context, action) {
+  let result;
+  if (!action.metadata?.usdtTransfer) {
+    result = { status: "unknown", reason: "MISSING_TRANSFER_SOURCE" };
+  } else {
+    try {
+      const data = parseTransferContext(context, action);
+      if (data.transfersUsdt && !data.sources.some((source) => source.role === "v3-pool")) {
+        result = { status: "unknown", reason: "MISSING_TRANSFER_SOURCE" };
+      } else {
+        const read = (name, address) => {
+          if (!context.runtime) throw new Error("USDT transfer validation requires a runtime");
+          return context.runtime.readContract(boolRead(context.chain.contracts.usdt, name, address));
+        };
+        result = await usdtValidateTransfer({
+          ...data,
+          reader: { paused: () => read("paused"), isBlackListed: (address) => read("isBlackListed", address) }
+        });
+      }
+    } catch {
+      result = { status: "unknown", reason: "CHECK_FAILED" };
+    }
+  }
+  if (result.status === "allowed") return;
+  throw new import_sun_sdk_core7.SDKError(
+    result.status === "blocked" ? "SDK_USDT_TRANSFER_BLOCKED" : "SDK_USDT_TRANSFER_UNKNOWN",
+    result.status === "blocked" ? "USDT transfer is currently restricted" : "Unable to verify USDT transfer status",
+    { ...result, usdtAddress: context.chain.contracts.usdt, actionId: action.id }
+  );
+}
+
+// src/positions/execute.ts
+async function assertV3PositionUsdtTransfer(context, action) {
+  await assertUsdtTransfer(context, action);
+}
+function createV3PositionsExecutor(context) {
+  const executor = createContextExecutor(context);
+  return {
+    ...executor,
+    sendAction: async (action) => {
+      await assertV3PositionUsdtTransfer(context, action);
+      if (!executor.sendAction) throw new import_sun_sdk_core8.SDKError("SDK_RUNTIME_ERROR", "V3 position execution requires a runtime");
+      return executor.sendAction(action);
+    }
+  };
+}
+
+// src/internal/method-parameters.ts
+var import_sun_sdk_core9 = require("@sun-protocol/sun-sdk-core");
+function methodParametersToAction(input) {
+  return (0, import_sun_sdk_core9.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/internal/positions.ts
+var import_sun_sdk_core10 = require("@sun-protocol/sun-sdk-core");
+function assertPositionAuthorized(input) {
+  const wallet = (0, import_sun_sdk_core10.assertTronAddress)(input.wallet, "wallet");
+  const owner = (0, import_sun_sdk_core10.assertTronAddress)(input.owner, "owner");
+  const approved = input.approved ? (0, import_sun_sdk_core10.assertTronAddress)(input.approved, "approved") : void 0;
+  if (wallet === owner || wallet === approved || input.operatorApproved === true) return;
+  throw new import_sun_sdk_core10.SDKError("SDK_WALLET_CAPABILITY_ERROR", "Wallet is not authorized for this position", {
+    tokenId: input.tokenId,
+    owner,
+    wallet,
+    operator: wallet
+  });
+}
+
+// src/internal/reads.ts
+var import_sun_sdk_core11 = 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_core11.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_core11.SDKError("SDK_CONTRACT_ERROR", `${operation} multicall item failed`, {
+        index,
+        call: calls[index],
+        error: result.error
+      });
+    }
+    return result.value;
+  });
+}
+
+// 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");
+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 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")
+  };
+}
+
+// src/positions/intents.ts
+var SUNSWAP_V3_POSITION_PROTOCOL_ID = "sunswap-v3";
+var SUNSWAP_V4_POSITION_PROTOCOL_ID = "sunswap-v4";
+function positionIntentScope(protocol, operation) {
+  return { domain: "position", protocol, operation };
+}
+
+// src/positions/v3.ts
+function integerString2(value, label) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    return BigInt(value.toString()).toString();
+  }
+  throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", `${label} must be an integer-like contract result`, { value });
+}
+function integerNumber2(value, label) {
+  const parsed = Number(integerString2(value, label));
+  if (!Number.isSafeInteger(parsed)) {
+    throw new import_sun_sdk_core13.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 parsePositionAddress(value, label) {
+  const raw = String(unwrapSingle(value));
+  try {
+    return (0, import_sun_sdk_core13.assertTronAddress)(raw, label);
+  } catch {
+    const evmHex = /^41[0-9a-fA-F]{40}$/.test(raw) ? `0x${raw.slice(2)}` : raw;
+    return evmHexToTronAddress(evmHex, label);
+  }
+}
+function normalizePositionToken(context, value, label) {
+  if (typeof value !== "string") {
+    throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", `${label} must be an address string`, { value });
+  }
+  const publicAddress = parsePositionAddress(value, label);
+  const evmAddress = tronAddressToEvmAddress(publicAddress, label);
+  return {
+    publicAddress,
+    token: new import_sun_sdk_core13.Token(context.chain.uniswapChainId, evmAddress, 6, void 0, void 0, true)
+  };
+}
+function parsePositionResult(context, tokenId, result, owner, approved, operatorApproved) {
+  let token0;
+  let token1;
+  let fee;
+  let tickLower;
+  let tickUpper;
+  let liquidity;
+  let tokensOwed0;
+  let tokensOwed1;
+  if (Array.isArray(result)) {
+    token0 = result[2];
+    token1 = result[3];
+    fee = result[4];
+    tickLower = result[5];
+    tickUpper = result[6];
+    liquidity = result[7];
+    tokensOwed0 = result[10];
+    tokensOwed1 = result[11];
+  } 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;
+    liquidity = position.liquidity;
+    tokensOwed0 = position.tokensOwed0;
+    tokensOwed1 = position.tokensOwed1;
+  } else {
+    throw new import_sun_sdk_core13.SDKError("SDK_CONTRACT_ERROR", "V3 position result is malformed", { result });
+  }
+  const token0Info = normalizePositionToken(context, token0, "token0");
+  const token1Info = normalizePositionToken(context, token1, "token1");
+  return {
+    protocol: "sunswap-v3",
+    tokenId,
+    owner,
+    ...approved !== void 0 ? { approved } : {},
+    ...operatorApproved !== void 0 ? { operatorApproved } : {},
+    token0: token0Info.publicAddress,
+    token1: token1Info.publicAddress,
+    fee: integerNumber2(fee, "fee"),
+    tickLower: integerNumber2(tickLower, "tickLower"),
+    tickUpper: integerNumber2(tickUpper, "tickUpper"),
+    liquidity: integerString2(liquidity, "liquidity"),
+    tokensOwed0: integerString2(tokensOwed0, "tokensOwed0"),
+    tokensOwed1: integerString2(tokensOwed1, "tokensOwed1"),
+    token0Entity: token0Info.token,
+    token1Entity: token1Info.token
+  };
+}
+function removePercentage(input, snapshot) {
+  if (input.percentage !== void 0) return normalizeLiquidityPercentage(input.percentage, "percentage");
+  const liquidity = BigInt(normalizeBaseUnitAmount(input.liquidity, "liquidity"));
+  const total = BigInt(snapshot.liquidity);
+  if (liquidity > total) {
+    throw new import_sun_sdk_core13.SDKError("SDK_INVALID_ARGUMENT", "liquidity cannot exceed position liquidity", {
+      liquidity: liquidity.toString(),
+      totalLiquidity: total.toString()
+    });
+  }
+  return new import_sun_sdk_core13.Percent(liquidity.toString(), total.toString());
+}
+function currencyForCollect(context, token, publicAddress, receiveNative) {
+  return receiveNative && publicAddress === context.chain.contracts.wtrx ? context.chain.nativeCurrency : token;
+}
+var V3PositionsClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  async read(input) {
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const [positionResult, ownerResult, approvedResult] = await readMulticallRequired(
+      this.context,
+      (0, import_sun_sdk_sunswap_v32.buildV3PositionReads)({
+        network: this.context.network,
+        tokenId,
+        positionManager: resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager")
+      }),
+      "V3 position read"
+    );
+    const owner = parsePositionAddress(ownerResult, "owner");
+    const approved = approvedResult ? parsePositionAddress(approvedResult, "approved") : void 0;
+    const operator = input.operator ? (0, import_sun_sdk_core13.assertTronAddress)(input.operator, "operator") : void 0;
+    const operatorApproved = operator ? Boolean(await readRequiredContract(
+      this.context,
+      (0, import_sun_sdk_sunswap_v32.buildV3PositionApprovalForAllRead)({
+        network: this.context.network,
+        owner,
+        operator,
+        positionManager: resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager")
+      }),
+      "V3 position operator approval read"
+    )) : void 0;
+    const snapshot = parsePositionResult(
+      this.context,
+      tokenId,
+      positionResult,
+      owner,
+      approved,
+      operatorApproved
+    );
+    return {
+      protocol: snapshot.protocol,
+      tokenId: snapshot.tokenId,
+      owner: snapshot.owner,
+      ...snapshot.approved !== void 0 ? { approved: snapshot.approved } : {},
+      ...snapshot.operatorApproved !== void 0 ? { operatorApproved: snapshot.operatorApproved } : {},
+      token0: snapshot.token0,
+      token1: snapshot.token1,
+      fee: snapshot.fee,
+      tickLower: snapshot.tickLower,
+      tickUpper: snapshot.tickUpper,
+      liquidity: snapshot.liquidity,
+      tokensOwed0: snapshot.tokensOwed0,
+      tokensOwed1: snapshot.tokensOwed1
+    };
+  }
+  remove = {
+    plan: async (input) => this.planRemove(input),
+    execute: async (input) => executeTransactionPlan(await this.planRemove(input), createV3PositionsExecutor(this.context))
+  };
+  collect = {
+    plan: async (input) => this.planCollect(input),
+    execute: async (input) => executeTransactionPlan(await this.planCollect(input), createV3PositionsExecutor(this.context))
+  };
+  usdtTransferContext(snapshot, positionManager, input) {
+    const { network, chain } = this.context;
+    const usdtAddress = chain.contracts.usdt;
+    const transfersUsdt = snapshot.token0 === usdtAddress || snapshot.token1 === usdtAddress;
+    const sources = [];
+    const factory = resolveProtocolContract(this.context, input.contracts, "sunswapV3Factory");
+    if (transfersUsdt && positionManager === chain.contracts.sunswapV3PositionManager && factory === chain.contracts.sunswapV3Factory) {
+      sources.push({
+        address: (0, import_sun_sdk_sunswap_v32.computeV3PoolAddress)({ network, tokenA: snapshot.token0, tokenB: snapshot.token1, fee: snapshot.fee, factory }),
+        role: "v3-pool"
+      });
+      sources.push({ address: positionManager, role: "position-manager" });
+    }
+    return { network, transfersUsdt, sources };
+  }
+  async readAuthorizedPosition(tokenId, operation, positionManager, validationMode) {
+    const wallet = await requireWalletAddress(this.context, operation);
+    const [positionResult, ownerResult, approvedResult] = await readMulticallRequired(
+      this.context,
+      (0, import_sun_sdk_sunswap_v32.buildV3PositionReads)({ network: this.context.network, tokenId, positionManager }),
+      operation
+    );
+    const owner = parsePositionAddress(ownerResult, "owner");
+    const approved = approvedResult ? parsePositionAddress(approvedResult, "approved") : void 0;
+    const operatorApproved = validationMode === "legacy" ? void 0 : Boolean(await readRequiredContract(
+      this.context,
+      (0, import_sun_sdk_sunswap_v32.buildV3PositionApprovalForAllRead)({ network: this.context.network, owner, operator: wallet, positionManager }),
+      `${operation} operator approval read`
+    ));
+    if (validationMode !== "legacy") {
+      assertPositionAuthorized({
+        tokenId,
+        wallet,
+        owner,
+        ...approved !== void 0 ? { approved } : {},
+        ...operatorApproved !== void 0 ? { operatorApproved } : {}
+      });
+    }
+    return {
+      wallet,
+      snapshot: parsePositionResult(this.context, tokenId, positionResult, owner, approved, operatorApproved)
+    };
+  }
+  async planRemove(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager");
+    const planId = nextPlanId(this.context, "position-v3-remove");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V3 remove position",
+      positionManager,
+      input.validationMode
+    );
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V3 remove position", wallet);
+    const deadline = normalizeDeadline(this.context, input);
+    const slippage = parseSlippage(input.slippage ?? "0.5%");
+    const poolDerived = input.pool === void 0;
+    const poolState = input.pool ?? await resolveV3PoolState(this.context, {
+      tokenA: snapshot.token0,
+      tokenB: snapshot.token1,
+      fee: snapshot.fee,
+      contracts: input.contracts
+    });
+    const pool = new import_sun_sdk_sunswap_v32.Pool({
+      tokenA: snapshot.token0Entity,
+      tokenB: snapshot.token1Entity,
+      fee: snapshot.fee,
+      sqrtRatioX96: normalizeBaseUnitAmount(poolState.sqrtRatioX96, "sqrtRatioX96"),
+      liquidity: normalizeBaseUnitAmount(poolState.liquidity, "pool liquidity", { allowZero: true }),
+      tickCurrent: poolState.tickCurrent,
+      ...poolState.tickSpacing !== void 0 ? { tickSpacing: poolState.tickSpacing } : {}
+    });
+    const position = new import_sun_sdk_sunswap_v32.Position({
+      pool,
+      tickLower: snapshot.tickLower,
+      tickUpper: snapshot.tickUpper,
+      liquidity: snapshot.liquidity
+    });
+    const token0 = (0, import_sun_sdk_core13.assertTronAddress)(snapshot.token0, "token0");
+    const token1 = (0, import_sun_sdk_core13.assertTronAddress)(snapshot.token1, "token1");
+    const expectedCurrencyOwed0 = import_sun_sdk_core13.CurrencyAmount.fromRawAmount(
+      currencyForCollect(this.context, snapshot.token0Entity, token0, input.receiveNative),
+      input.expectedCurrencyOwed0 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed0, "expectedCurrencyOwed0", { allowZero: true }) : snapshot.tokensOwed0
+    );
+    const expectedCurrencyOwed1 = import_sun_sdk_core13.CurrencyAmount.fromRawAmount(
+      currencyForCollect(this.context, snapshot.token1Entity, token1, input.receiveNative),
+      input.expectedCurrencyOwed1 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed1, "expectedCurrencyOwed1", { allowZero: true }) : snapshot.tokensOwed1
+    );
+    const methodParameters = import_sun_sdk_sunswap_v32.NonfungiblePositionManager.removeCallParameters(position, {
+      tokenId,
+      liquidityPercentage: removePercentage(input, snapshot),
+      slippageTolerance: slippage,
+      deadline,
+      ...input.burnToken !== void 0 ? { burnToken: input.burnToken } : {},
+      collectOptions: {
+        recipient: tronAddressToEvmAddress(recipient, "recipient"),
+        expectedCurrencyOwed0,
+        expectedCurrencyOwed1
+      }
+    });
+    const action = methodParametersToAction({
+      id: `${planId}-tx`,
+      target: positionManager,
+      methodParameters,
+      metadata: { usdtTransfer: this.usdtTransferContext(snapshot, positionManager, input) },
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      intent: {
+        kind: "remove-liquidity",
+        scope: positionIntentScope(SUNSWAP_V3_POSITION_PROTOCOL_ID, "remove-position"),
+        positionId: tokenId
+      }
+    });
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: { title: "Remove SunSwap V3 position liquidity", lines: [`Position ${tokenId}`, `Recipient ${recipient}`] },
+      approvals: [],
+      transactions: [action],
+      metadata: {
+        protocol: "sunswap-v3",
+        operation: "remove-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient,
+        deadline,
+        slippageBips: slippageToBips(input.slippage ?? "0.5%"),
+        positionDerived: true,
+        poolDerived
+      }
+    };
+  }
+  async planCollect(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV3PositionManager");
+    const planId = nextPlanId(this.context, "position-v3-collect");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V3 collect position",
+      positionManager,
+      input.validationMode
+    );
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V3 collect position", wallet);
+    const token0 = (0, import_sun_sdk_core13.assertTronAddress)(snapshot.token0, "token0");
+    const token1 = (0, import_sun_sdk_core13.assertTronAddress)(snapshot.token1, "token1");
+    const methodParameters = import_sun_sdk_sunswap_v32.NonfungiblePositionManager.collectCallParameters({
+      tokenId,
+      recipient: tronAddressToEvmAddress(recipient, "recipient"),
+      expectedCurrencyOwed0: import_sun_sdk_core13.CurrencyAmount.fromRawAmount(
+        currencyForCollect(this.context, snapshot.token0Entity, token0, input.receiveNative),
+        input.expectedCurrencyOwed0 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed0, "expectedCurrencyOwed0", { allowZero: true }) : snapshot.tokensOwed0
+      ),
+      expectedCurrencyOwed1: import_sun_sdk_core13.CurrencyAmount.fromRawAmount(
+        currencyForCollect(this.context, snapshot.token1Entity, token1, input.receiveNative),
+        input.expectedCurrencyOwed1 !== void 0 ? normalizeBaseUnitAmount(input.expectedCurrencyOwed1, "expectedCurrencyOwed1", { allowZero: true }) : snapshot.tokensOwed1
+      )
+    });
+    const action = methodParametersToAction({
+      id: `${planId}-tx`,
+      target: positionManager,
+      methodParameters,
+      metadata: { usdtTransfer: this.usdtTransferContext(snapshot, positionManager, input) },
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      intent: {
+        kind: "collect-fees",
+        scope: positionIntentScope(SUNSWAP_V3_POSITION_PROTOCOL_ID, "collect-position"),
+        positionId: tokenId
+      }
+    });
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: { title: "Collect SunSwap V3 position fees", lines: [`Position ${tokenId}`, `Recipient ${recipient}`] },
+      approvals: [],
+      transactions: [action],
+      metadata: {
+        protocol: "sunswap-v3",
+        operation: "collect-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient
+      }
+    };
+  }
+};
+
+// src/positions/v4.ts
+var import_sun_sdk_core14 = require("@sun-protocol/sun-sdk-core");
+var import_sun_sdk_sunswap_v33 = require("@sun-protocol/sun-sdk-sunswap-v3");
+var import_sun_sdk_sunswap_v4 = require("@sun-protocol/sun-sdk-sunswap-v4");
+var Q96 = 1n << 96n;
+function parseString(value, label) {
+  if (typeof value === "bigint" || typeof value === "number" || typeof value === "string") {
+    return BigInt(value.toString()).toString();
+  }
+  throw new import_sun_sdk_core14.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_core14.SDKError("SDK_CONTRACT_ERROR", `${label} must be a safe integer`, { value });
+  }
+  return parsed;
+}
+function unwrapSingle2(value) {
+  return Array.isArray(value) && value.length === 1 ? value[0] : value;
+}
+function parseAddress(value, label) {
+  const raw = String(unwrapSingle2(value));
+  try {
+    return (0, import_sun_sdk_core14.assertTronAddress)(raw, label);
+  } catch {
+    const evmHex = /^41[0-9a-fA-F]{40}$/.test(raw) ? `0x${raw.slice(2)}` : raw;
+    return evmHexToTronAddress(evmHex, label);
+  }
+}
+function parsePoolKey(value, network) {
+  if (Array.isArray(value) && value.length >= 5) {
+    return (0, import_sun_sdk_sunswap_v4.createV4PoolKey)({
+      network,
+      currencyA: parseAddress(value[0], "poolKey.currency0"),
+      currencyB: parseAddress(value[1], "poolKey.currency1"),
+      hooks: parseAddress(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: parseAddress(key.currency0, "poolKey.currency0"),
+        currencyB: parseAddress(key.currency1, "poolKey.currency1"),
+        hooks: parseAddress(key.hooks, "poolKey.hooks"),
+        fee: parseNumber(key.fee, "poolKey.fee"),
+        parameters: String(key.parameters)
+      });
+    }
+  }
+  return void 0;
+}
+function signed24(value) {
+  const masked = value & 0xffffffn;
+  return Number((masked & 0x800000n) === 0n ? masked : masked - 0x1000000n);
+}
+function parsePackedPositionInfo(value) {
+  const info = BigInt(String(unwrapSingle2(value)));
+  return {
+    tickLower: signed24(info >> 8n),
+    tickUpper: signed24(info >> 32n)
+  };
+}
+function parseOptionalPoolInfo(result, network) {
+  if (Array.isArray(result)) {
+    const poolKey = parsePoolKey(result[0], network);
+    const ticks = result[2] !== void 0 ? {
+      tickLower: parseNumber(result[1], "tickLower"),
+      tickUpper: parseNumber(result[2], "tickUpper")
+    } : result[1] !== void 0 ? parsePackedPositionInfo(result[1]) : {};
+    return {
+      ...poolKey !== void 0 ? { poolKey } : {},
+      ...ticks
+    };
+  }
+  if (typeof result === "object" && result !== null) {
+    const info = result;
+    const poolKey = parsePoolKey(info.poolKey, network);
+    return {
+      ...poolKey !== void 0 ? { poolKey } : {},
+      ...info.tickLower !== void 0 ? { tickLower: parseNumber(info.tickLower, "tickLower") } : {},
+      ...info.tickUpper !== void 0 ? { tickUpper: parseNumber(info.tickUpper, "tickUpper") } : {}
+    };
+  }
+  return {};
+}
+function parseFeesResult(result) {
+  const value = unwrapSingle2(result);
+  if (Array.isArray(value) && value.length >= 2) {
+    return {
+      feesOwed0: parseString(value[0], "feesOwed0"),
+      feesOwed1: parseString(value[1], "feesOwed1")
+    };
+  }
+  if (typeof value === "object" && value !== null) {
+    const fees = value;
+    if (fees.feesOwed0 !== void 0 && fees.feesOwed1 !== void 0) {
+      return {
+        feesOwed0: parseString(fees.feesOwed0, "feesOwed0"),
+        feesOwed1: parseString(fees.feesOwed1, "feesOwed1")
+      };
+    }
+  }
+  throw new import_sun_sdk_core14.SDKError("SDK_CONTRACT_ERROR", "V4 position fee result is malformed", { result });
+}
+function liquidityFromPercentage(totalLiquidity, percentage) {
+  const total = BigInt(normalizeBaseUnitAmount(totalLiquidity, "currentLiquidity"));
+  const numerator = BigInt(percentage.numerator.toString());
+  const denominator = BigInt(percentage.denominator.toString());
+  const liquidity = total * numerator / denominator;
+  if (liquidity <= 0n) {
+    throw new import_sun_sdk_core14.SDKError("SDK_INVALID_ARGUMENT", "percentage resolves to zero liquidity", {
+      totalLiquidity: total.toString(),
+      percentage: percentage.toSignificant()
+    });
+  }
+  return liquidity.toString();
+}
+function resolveRemoveLiquidity(input, snapshotLiquidity) {
+  const normalizedSnapshotLiquidity = normalizeBaseUnitAmount(snapshotLiquidity, "position liquidity");
+  if (input.currentLiquidity !== void 0 && input.validationMode !== "legacy") {
+    const expectedLiquidity = normalizeBaseUnitAmount(input.currentLiquidity, "currentLiquidity");
+    if (expectedLiquidity !== normalizedSnapshotLiquidity) {
+      throw new import_sun_sdk_core14.SDKError("SDK_INVALID_ARGUMENT", "currentLiquidity is stale and does not match the on-chain position", {
+        currentLiquidity: expectedLiquidity,
+        positionLiquidity: normalizedSnapshotLiquidity
+      });
+    }
+  }
+  const liquidity = input.liquidity !== void 0 ? normalizeBaseUnitAmount(input.liquidity, "liquidity") : liquidityFromPercentage(normalizedSnapshotLiquidity, normalizeLiquidityPercentage(input.percentage, "percentage"));
+  if (BigInt(liquidity) > BigInt(normalizedSnapshotLiquidity) && input.validationMode === "legacy") {
+    return normalizedSnapshotLiquidity;
+  }
+  if (BigInt(liquidity) > BigInt(normalizedSnapshotLiquidity)) {
+    throw new import_sun_sdk_core14.SDKError("SDK_INVALID_ARGUMENT", "liquidity cannot exceed on-chain position liquidity", {
+      liquidity,
+      positionLiquidity: normalizedSnapshotLiquidity
+    });
+  }
+  return liquidity;
+}
+function parseSqrtPriceX96(result) {
+  const value = Array.isArray(result) ? result[0] : typeof result === "object" && result !== null ? result.sqrtPriceX96 : void 0;
+  try {
+    const parsed = BigInt(String(value));
+    if (parsed <= 0n) throw new Error("non-positive");
+    return parsed;
+  } catch {
+    throw new import_sun_sdk_core14.SDKError("SDK_CONTRACT_ERROR", "V4 slot0 result has an invalid sqrtPriceX96", { result });
+  }
+}
+function removalAmounts(snapshot, liquidity, sqrtPriceX96) {
+  if (snapshot.tickLower === void 0 || snapshot.tickUpper === void 0) {
+    throw new import_sun_sdk_core14.SDKError("SDK_CONTRACT_ERROR", "V4 position is missing ticks required to derive removal minimums", {
+      tokenId: snapshot.tokenId
+    });
+  }
+  const sqrtA = BigInt(import_sun_sdk_sunswap_v33.TickMath.getSqrtRatioAtTick(snapshot.tickLower).toString());
+  const sqrtB = BigInt(import_sun_sdk_sunswap_v33.TickMath.getSqrtRatioAtTick(snapshot.tickUpper).toString());
+  const positionLiquidity = BigInt(liquidity);
+  if (sqrtPriceX96 <= sqrtA) {
+    return [positionLiquidity * (sqrtB - sqrtA) * Q96 / (sqrtA * sqrtB), 0n];
+  }
+  if (sqrtPriceX96 < sqrtB) {
+    return [
+      positionLiquidity * (sqrtB - sqrtPriceX96) * Q96 / (sqrtPriceX96 * sqrtB),
+      positionLiquidity * (sqrtPriceX96 - sqrtA) / Q96
+    ];
+  }
+  return [0n, positionLiquidity * (sqrtB - sqrtA) / Q96];
+}
+function resolvePositionPoolKey(tokenId, supplied, snapshot) {
+  if (snapshot.poolKey === void 0) {
+    throw new import_sun_sdk_core14.SDKError("SDK_CONTRACT_ERROR", "V4 position does not include a poolKey", { tokenId });
+  }
+  if (supplied !== void 0) {
+    const suppliedPoolId = (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(supplied);
+    const positionPoolId = (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(snapshot.poolKey);
+    if (suppliedPoolId !== positionPoolId) {
+      throw new import_sun_sdk_core14.SDKError("SDK_INVALID_ARGUMENT", "V4 poolKey does not match the tokenId position", {
+        tokenId,
+        suppliedPoolId,
+        positionPoolId
+      });
+    }
+    return { poolKey: supplied, derived: false };
+  }
+  return { poolKey: snapshot.poolKey, derived: true };
+}
+function assertTriggerRecipient(wallet, recipient, operation) {
+  if (wallet !== recipient) {
+    throw new import_sun_sdk_core14.SDKError("SDK_INVALID_ARGUMENT", `${operation} recipient must match the triggering wallet`, {
+      wallet,
+      recipient
+    });
+  }
+}
+function metadata(input) {
+  return {
+    protocol: "sunswap-v4",
+    operation: input.operation,
+    tokenId: input.tokenId,
+    ...input.owner !== void 0 ? { owner: input.owner } : {},
+    ...input.recipient !== void 0 ? { recipient: input.recipient } : {},
+    ...input.deadline !== void 0 ? { deadline: input.deadline } : {},
+    ...input.slippageBips !== void 0 ? { slippageBips: input.slippageBips } : {},
+    ...input.poolKeyDerived !== void 0 ? { poolKeyDerived: input.poolKeyDerived } : {}
+  };
+}
+var V4PositionsClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  async read(input) {
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const reads = (0, import_sun_sdk_sunswap_v4.buildV4PositionReads)({ network: this.context.network, tokenId, positionManager });
+    const [poolInfoResult, liquidityResult, ownerResult, approvedResult] = await readMulticallRequired(
+      this.context,
+      reads,
+      "V4 position read"
+    );
+    const owner = parseAddress(ownerResult, "owner");
+    const approved = approvedResult ? parseAddress(approvedResult, "approved") : void 0;
+    const operator = input.operator ? (0, import_sun_sdk_core14.assertTronAddress)(input.operator, "operator") : void 0;
+    const operatorApproved = operator ? Boolean(await readRequiredContract(
+      this.context,
+      (0, import_sun_sdk_sunswap_v4.buildV4PositionApprovalForAllRead)({ network: this.context.network, owner, operator, positionManager }),
+      "V4 position operator approval read"
+    ).then(unwrapSingle2)) : void 0;
+    return {
+      protocol: "sunswap-v4",
+      tokenId,
+      owner,
+      ...approved !== void 0 ? { approved } : {},
+      ...operatorApproved !== void 0 ? { operatorApproved } : {},
+      ...parseOptionalPoolInfo(poolInfoResult, this.context.network),
+      liquidity: parseString(unwrapSingle2(liquidityResult), "liquidity")
+    };
+  }
+  async fees(input) {
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const snapshot = await this.read(input);
+    if (snapshot.poolKey === void 0 || snapshot.tickLower === void 0 || snapshot.tickUpper === void 0) {
+      throw new import_sun_sdk_core14.SDKError("SDK_CONTRACT_ERROR", "V4 position does not include the context required to read fees", {
+        tokenId
+      });
+    }
+    const result = await readRequiredContract(
+      this.context,
+      (0, import_sun_sdk_sunswap_v4.buildV4PositionFeesRead)({
+        network: this.context.network,
+        tokenId,
+        poolId: (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(snapshot.poolKey),
+        tickLower: snapshot.tickLower,
+        tickUpper: snapshot.tickUpper,
+        poolManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PoolManager"),
+        positionManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager"),
+        lpFeeHelper: resolveProtocolContract(this.context, input.contracts, "sunswapV4LpFeeHelper")
+      }),
+      "V4 position fee read"
+    );
+    return {
+      protocol: "sunswap-v4",
+      tokenId,
+      ...parseFeesResult(result)
+    };
+  }
+  remove = {
+    plan: async (input) => this.planRemove(input),
+    execute: async (input) => executeTransactionPlan(await this.planRemove(input), createContextExecutor(this.context))
+  };
+  collect = {
+    plan: async (input) => this.planCollect(input),
+    execute: async (input) => executeTransactionPlan(await this.planCollect(input), createContextExecutor(this.context))
+  };
+  async readAuthorizedPosition(tokenId, operation, contracts, validationMode) {
+    const wallet = await requireWalletAddress(this.context, operation);
+    const snapshot = await this.read({
+      tokenId,
+      ...validationMode === "legacy" ? {} : { operator: wallet },
+      ...contracts !== void 0 ? { contracts } : {}
+    });
+    if (validationMode !== "legacy") {
+      assertPositionAuthorized({
+        tokenId,
+        wallet,
+        owner: snapshot.owner,
+        ...snapshot.approved !== void 0 ? { approved: snapshot.approved } : {},
+        ...snapshot.operatorApproved !== void 0 ? { operatorApproved: snapshot.operatorApproved } : {}
+      });
+    }
+    return { wallet, snapshot };
+  }
+  async planRemove(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "position-v4-remove");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V4 remove position",
+      input.contracts,
+      input.validationMode
+    );
+    const poolKey = resolvePositionPoolKey(tokenId, input.poolKey, snapshot);
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V4 remove position", wallet);
+    assertTriggerRecipient(wallet, recipient, "V4 remove position");
+    const deadline = normalizeDeadline(this.context, input);
+    const slippageBips = slippageToBips(input.slippage ?? "0.5%");
+    const liquidity = resolveRemoveLiquidity(input, snapshot.liquidity);
+    const derivedAmounts = input.amount0Min === void 0 || input.amount1Min === void 0 ? removalAmounts(
+      snapshot,
+      liquidity,
+      parseSqrtPriceX96(await readRequiredContract(
+        this.context,
+        (0, import_sun_sdk_sunswap_v4.buildV4PoolSlot0Read)({
+          network: this.context.network,
+          poolId: (0, import_sun_sdk_sunswap_v4.computeV4PoolId)(poolKey.poolKey),
+          poolManager: resolveProtocolContract(this.context, input.contracts, "sunswapV4PoolManager")
+        }),
+        "V4 removal minimum quote"
+      ))
+    ) : void 0;
+    const amount0Min = input.amount0Min !== void 0 ? normalizeBaseUnitAmount(input.amount0Min, "amount0Min", { allowZero: true }) : input.roundingMode === "half-up" ? (((derivedAmounts?.[0] ?? 0n) * BigInt(1e4 - slippageBips) + 5000n) / 10000n).toString() : applySlippageMin(derivedAmounts?.[0] ?? 0n, slippageBips).toString();
+    const amount1Min = input.amount1Min !== void 0 ? normalizeBaseUnitAmount(input.amount1Min, "amount1Min", { allowZero: true }) : input.roundingMode === "half-up" ? (((derivedAmounts?.[1] ?? 0n) * BigInt(1e4 - slippageBips) + 5000n) / 10000n).toString() : applySlippageMin(derivedAmounts?.[1] ?? 0n, slippageBips).toString();
+    const decreaseAction = (0, import_sun_sdk_sunswap_v4.buildV4DecreaseLiquidityAction)({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      tokenId,
+      liquidity,
+      amount0Min,
+      amount1Min,
+      recipient,
+      deadline,
+      ...input.settlementMode !== void 0 ? { settlementMode: input.settlementMode } : {},
+      ...input.hookData !== void 0 ? { hookData: input.hookData } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const transactionAction = input.transactionMode === "multicall" ? (0, import_sun_sdk_sunswap_v4.buildV4MulticallAction)({
+      network: this.context.network,
+      positionManager,
+      calls: [(0, import_sun_sdk_sunswap_v4.encodeV4ContractCallAction)(decreaseAction)],
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    }) : decreaseAction;
+    const action = {
+      ...transactionAction,
+      intent: {
+        kind: "remove-liquidity",
+        scope: positionIntentScope(SUNSWAP_V4_POSITION_PROTOCOL_ID, "remove-position"),
+        positionId: tokenId
+      }
+    };
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: {
+        title: "Remove SunSwap V4 position liquidity",
+        lines: [`Position ${tokenId}`, `Recipient ${recipient}`]
+      },
+      approvals: [],
+      transactions: [action],
+      metadata: metadata({
+        operation: "remove-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient,
+        deadline,
+        slippageBips,
+        poolKeyDerived: poolKey.derived
+      })
+    };
+  }
+  async planCollect(input) {
+    const positionManager = resolveProtocolContract(this.context, input.contracts, "sunswapV4PositionManager");
+    const planId = nextPlanId(this.context, "position-v4-collect");
+    const tokenId = normalizeBaseUnitAmount(input.tokenId, "tokenId");
+    const { wallet, snapshot } = await this.readAuthorizedPosition(
+      tokenId,
+      "V4 collect position",
+      input.contracts,
+      input.validationMode
+    );
+    const poolKey = resolvePositionPoolKey(tokenId, input.poolKey, snapshot);
+    const recipient = await normalizeRecipient(this.context, input.recipient, "V4 collect position", wallet);
+    assertTriggerRecipient(wallet, recipient, "V4 collect position");
+    const deadline = normalizeDeadline(this.context, input);
+    const action = (0, import_sun_sdk_sunswap_v4.buildV4CollectAction)({
+      network: this.context.network,
+      positionManager,
+      poolKey: poolKey.poolKey,
+      tokenId,
+      recipient,
+      deadline,
+      ...input.settlementMode !== void 0 ? { settlementMode: input.settlementMode } : {},
+      ...input.hookData !== void 0 ? { hookData: input.hookData } : {},
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    });
+    const transactionAction = input.transactionMode === "multicall" ? (0, import_sun_sdk_sunswap_v4.buildV4MulticallAction)({
+      network: this.context.network,
+      positionManager,
+      calls: [(0, import_sun_sdk_sunswap_v4.encodeV4ContractCallAction)(action)],
+      ...input.feeLimit !== void 0 ? { feeLimit: input.feeLimit } : {},
+      id: `${planId}-tx`
+    }) : action;
+    const transaction = {
+      ...transactionAction,
+      intent: {
+        kind: "collect-fees",
+        scope: positionIntentScope(SUNSWAP_V4_POSITION_PROTOCOL_ID, "collect-position"),
+        positionId: tokenId
+      }
+    };
+    return {
+      id: planId,
+      kind: "position",
+      network: this.context.network,
+      owner: wallet,
+      summary: {
+        title: "Collect SunSwap V4 position fees",
+        lines: [`Position ${tokenId}`, `Recipient ${recipient}`]
+      },
+      approvals: [],
+      transactions: [transaction],
+      metadata: metadata({
+        operation: "collect-position",
+        tokenId,
+        owner: snapshot.owner,
+        recipient,
+        deadline,
+        poolKeyDerived: poolKey.derived
+      })
+    };
+  }
+};
+
+// src/positions/client.ts
+var PositionsClient = class {
+  v3;
+  v4;
+  constructor(context) {
+    const v3Client = new V3PositionsClient(context);
+    const v4Client = new V4PositionsClient(context);
+    this.v3 = {
+      read: (input) => v3Client.read(input),
+      remove: v3Client.remove,
+      collect: v3Client.collect
+    };
+    this.v4 = {
+      read: (input) => v4Client.read(input),
+      fees: (input) => v4Client.fees(input),
+      remove: v4Client.remove,
+      collect: v4Client.collect
+    };
+  }
+};
+function createPositionsClient(context) {
+  return new PositionsClient(context);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PositionsClient,
+  SUNSWAP_V3_POSITION_PROTOCOL_ID,
+  SUNSWAP_V4_POSITION_PROTOCOL_ID,
+  V3PositionsClient,
+  V4PositionsClient,
+  assertV3PositionUsdtTransfer,
+  createPositionsClient,
+  createV3PositionsExecutor
+});
+//# sourceMappingURL=index.cjs.map