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

package/dist/swap/index.cjs

@@ -0,0 +1,2259 @@
+"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/swap/index.ts
+var swap_exports = {};
+__export(swap_exports, {
+  PSM_PROTOCOL_ID: () => PSM_PROTOCOL_ID,
+  PsmSwapClient: () => PsmSwapClient,
+  SwapRouterClient: () => SwapRouterClient,
+  UNIVERSAL_ROUTER_PROTOCOL_ID: () => UNIVERSAL_ROUTER_PROTOCOL_ID,
+  V2SwapClient: () => V2SwapClient,
+  WTRX_PROTOCOL_ID: () => WTRX_PROTOCOL_ID,
+  createPsmClient: () => createPsmClient,
+  createPsmSwapClient: () => createPsmSwapClient,
+  createRouterSwapExecutor: () => createRouterSwapExecutor,
+  createSwapRouterClient: () => createSwapRouterClient,
+  createV2Client: () => createV2Client,
+  createV2SwapClient: () => createV2SwapClient,
+  createV2SwapExecutor: () => createV2SwapExecutor,
+  detectWtrxSwap: () => detectWtrxSwap,
+  isNativeTrxToken: () => isNativeTrxToken,
+  isWrappedTrxToken: () => isWrappedTrxToken,
+  materializeUniversalRouterAction: () => materializeUniversalRouterAction,
+  normalizeRouterToken: () => normalizeRouterToken,
+  normalizeV2TrxPairPath: () => normalizeV2TrxPairPath,
+  planPsmSwap: () => planPsmSwap,
+  planRouterSwap: () => planRouterSwap,
+  quotePsmSwap: () => quotePsmSwap,
+  quoteRouterSwap: () => quoteRouterSwap,
+  quoteSwap: () => quoteSwap,
+  readPsm: () => readPsm
+});
+module.exports = __toCommonJS(swap_exports);
+
+// 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 createDefaultIdFactory() {
+  let nextPlanId2 = 0;
+  return () => {
+    nextPlanId2 += 1;
+    return `sun-plan-${nextPlanId2}`;
+  };
+}
+function createProtocolsContext(options) {
+  if (options.runtime && (options.tronClient || options.wallet || options.getWallet || options.onSubmitted)) {
+    throw new import_sun_sdk_core2.SDKError(
+      "SDK_INVALID_ARGUMENT",
+      "Use either runtime or tronClient/wallet/onSubmitted when creating a protocol client"
+    );
+  }
+  if (options.wallet && !options.tronClient) {
+    throw new import_sun_sdk_core2.SDKError("SDK_INVALID_ARGUMENT", "wallet requires a tronClient");
+  }
+  if (options.getWallet && !options.tronClient) {
+    throw new import_sun_sdk_core2.SDKError("SDK_INVALID_ARGUMENT", "getWallet requires a tronClient");
+  }
+  if (options.wallet && options.getWallet) {
+    throw new import_sun_sdk_core2.SDKError("SDK_INVALID_ARGUMENT", "Use either wallet or getWallet when creating a protocol client");
+  }
+  const runtime = options.runtime ?? (options.tronClient ? (0, import_sun_sdk_runtime.createRuntime)({
+    network: options.network,
+    tronClient: options.tronClient,
+    ...options.wallet ? { wallet: options.wallet } : {},
+    ...options.getWallet ? { getWallet: options.getWallet } : {},
+    ...options.onSubmitted ? { onSubmitted: options.onSubmitted } : {}
+  }) : void 0);
+  if (runtime && runtime.network !== options.network) {
+    throw new import_sun_sdk_core2.SDKError("SDK_INVALID_ARGUMENT", "Protocols runtime network mismatch", {
+      sdkNetwork: options.network,
+      runtimeNetwork: runtime.network
+    });
+  }
+  const chain = (0, import_sun_sdk_chains.getChainConfig)(options.network);
+  const endpoints = { ...(0, import_sun_sdk_chains.getNetworkEndpoints)(options.network), ...options.endpoints };
+  const fetchImpl = options.fetchImpl ?? import_sun_sdk_api2.defaultFetch;
+  const jsonParser = options.jsonParser ?? import_sun_sdk_api2.defaultJsonParser;
+  const now = options.now ?? Date.now;
+  const getTransactionTime = options.getTransactionTime ?? (() => (0, import_sun_sdk_api2.getServerTime)(endpoints.time, fetchImpl, jsonParser));
+  const sunPumpApi = options.clients?.sunPumpApi ?? (endpoints.sunPump ? new import_sun_sdk_api2.SunPumpApiClient({ baseUrl: endpoints.sunPump, fetchImpl, jsonParser }) : void 0);
+  return {
+    network: options.network,
+    chain,
+    endpoints,
+    ...runtime ? { runtime } : {},
+    fetchImpl,
+    jsonParser,
+    routerApi: options.clients?.routerApi ?? new import_sun_sdk_api2.RouterApiClient({ fetchImpl, jsonParser }),
+    ...sunPumpApi ? { sunPumpApi } : {},
+    adapters: options.adapters ?? {},
+    now,
+    getTransactionTime: async () => {
+      try {
+        const timestamp = await getTransactionTime();
+        if (Number.isSafeInteger(timestamp) && timestamp > 0) return timestamp;
+      } catch {
+      }
+      return now();
+    },
+    idFactory: options.idFactory ?? createDefaultIdFactory()
+  };
+}
+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/execute-plan.ts
+var import_sun_sdk_core4 = require("@sun-protocol/sun-sdk-core");
+
+// src/errors.ts
+var import_sun_sdk_core3 = 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_core3.SDKError) return error;
+  const code = isWalletRejection(error) ? "SDK_WALLET_REJECTED" : fallbackCode;
+  return new import_sun_sdk_core3.SDKError(code, message, { ...context, cause: error });
+}
+function withExecutionContext(error, context) {
+  return new import_sun_sdk_core3.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_core4.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_core4.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_core4.SDKError(
+          "SDK_RUNTIME_ERROR",
+          `Runtime action ${action.id} materialized to unsupported type: ${action.type}`
+        );
+      }
+      if (!executor.sendAction) {
+        throw new import_sun_sdk_core4.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_core4.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_core4.SDKError("SDK_INVALID_ARGUMENT", `Action ${action.id} is missing typedData`);
+      }
+      if (!executor.signTypedData) {
+        throw new import_sun_sdk_core4.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_core4.SDKError("SDK_RUNTIME_ERROR", `Action ${action.id} requires an API executor`);
+      }
+      return { action, result: await executor.executeHttpAction(action) };
+    }
+    throw new import_sun_sdk_core4.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_core4.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_core4.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_core4.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_core4.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_core4.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
+  };
+}
+function isTransactionPlan(input) {
+  if (typeof input !== "object" || input === null) return false;
+  const candidate = input;
+  return Array.isArray(candidate.approvals) && Array.isArray(candidate.transactions);
+}
+async function executePlanTransactions(plan, executor) {
+  const result = await executeTransactionPlan(
+    { ...plan, approvals: [] },
+    executor
+  );
+  return { ...result, plan };
+}
+
+// src/swap/router-execute.ts
+var import_sun_sdk_core10 = require("@sun-protocol/sun-sdk-core");
+
+// src/internal/router-action.ts
+var import_sun_sdk_core5 = require("@sun-protocol/sun-sdk-core");
+var UNIVERSAL_ROUTER_MATERIALIZATION_KIND = "universal-router-swap";
+function toJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(toJsonValue);
+  }
+  if (typeof value === "object") {
+    const objectValue = value;
+    const result = {};
+    for (const [key, entry] of Object.entries(objectValue)) {
+      if (entry !== void 0) {
+        result[key] = toJsonValue(entry);
+      }
+    }
+    return result;
+  }
+  throw new TypeError(`Value is not JSON-serializable: ${typeof value}`);
+}
+function toJsonObject(value) {
+  const normalized = toJsonValue(value);
+  if (normalized === null || Array.isArray(normalized) || typeof normalized !== "object") {
+    throw new TypeError("Value is not a JSON object");
+  }
+  return normalized;
+}
+function createUniversalRouterDeferredAction(input) {
+  return (0, import_sun_sdk_core5.createDeferredContractCallAction)({
+    id: input.id,
+    materialization: {
+      kind: UNIVERSAL_ROUTER_MATERIALIZATION_KIND,
+      data: toJsonObject(input.data)
+    },
+    ...input.intent !== void 0 ? { intent: input.intent } : {}
+  });
+}
+
+// src/internal/universal-router-adapter.ts
+var import_sun_sdk_core8 = require("@sun-protocol/sun-sdk-core");
+var import_universal_router_sdk = require("@sun-protocol/universal-router-sdk");
+var import_sun_sdk_sunswap_v3 = require("@sun-protocol/sun-sdk-sunswap-v3");
+
+// 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");
+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);
+}
+
+// src/common.ts
+var import_sun_sdk_core7 = require("@sun-protocol/sun-sdk-core");
+var PERCENT_PATTERN = /^(\d+)(?:\.(\d+))?%$/;
+var BASE_UNIT_PATTERN = /^\d+$/;
+function parseSlippage(value) {
+  if (value instanceof import_sun_sdk_core7.Percent) {
+    validateSlippage(value);
+    return value;
+  }
+  const match = PERCENT_PATTERN.exec(value);
+  if (!match) {
+    throw new import_sun_sdk_core7.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_core7.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_core7.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_core7.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 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_core7.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_core7.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_core7.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_core7.SDKError("SDK_INVALID_ARGUMENT", "ttlSeconds must be a positive safe integer", {
+      ttlSeconds
+    });
+  }
+  return (BigInt(Math.floor(context.now() / 1e3)) + BigInt(ttlSeconds)).toString();
+}
+function normalizeTransactionValidForSeconds(value) {
+  const transactionValidForSeconds = value ?? 1200;
+  if (!Number.isSafeInteger(transactionValidForSeconds) || transactionValidForSeconds <= 0) {
+    throw new import_sun_sdk_core7.SDKError(
+      "SDK_INVALID_ARGUMENT",
+      "transactionValidForSeconds must be a positive safe integer",
+      { transactionValidForSeconds }
+    );
+  }
+  return transactionValidForSeconds;
+}
+function normalizeFeeLimit(value, defaultValue) {
+  const feeLimit = value ?? defaultValue;
+  if (!Number.isSafeInteger(feeLimit) || feeLimit <= 0) {
+    throw new import_sun_sdk_core7.SDKError("SDK_INVALID_ARGUMENT", "feeLimit must be a positive safe integer in sun", {
+      feeLimit
+    });
+  }
+  return feeLimit;
+}
+async function resolveTransactionDeadline(context, transactionValidForSeconds) {
+  const nowSeconds = BigInt(Math.ceil(await context.getTransactionTime() / 1e3));
+  return (nowSeconds + BigInt(transactionValidForSeconds)).toString();
+}
+async function normalizeRecipient(context, recipient, operation, walletAddress) {
+  if (recipient !== void 0) return (0, import_sun_sdk_core7.assertTronAddress)(recipient, "recipient");
+  if (walletAddress !== void 0) return walletAddress;
+  return requireWalletAddress(context, operation);
+}
+function nextPlanId(context, prefix) {
+  return `${prefix}-${context.idFactory()}`;
+}
+
+// src/swap/fee-limit.ts
+var DEFAULT_WTRX_SWAP_FEE_LIMIT = 1e9;
+var DEFAULT_UNIVERSAL_ROUTER_SWAP_FEE_LIMIT = 5e8;
+var DEFAULT_PSM_SWAP_FEE_LIMIT = 25e7;
+var DEFAULT_PSM_APPROVAL_FEE_LIMIT = 1e9;
+
+// src/internal/universal-router-adapter.ts
+function requireString(route, key) {
+  const value = route[key];
+  if (typeof value !== "string") {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", `Router route is missing ${String(key)}`, { key, route });
+  }
+  return value;
+}
+function requireStringArray(route, key) {
+  const value = route[key];
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", `Router route is missing ${String(key)}`, { key, route });
+  }
+  return value;
+}
+function normalizePoolKey(poolKey) {
+  if (poolKey === null || poolKey === void 0) {
+    return null;
+  }
+  if (typeof poolKey !== "object") {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", "Router route poolKey must be an object or null", { poolKey });
+  }
+  const value = poolKey;
+  const token0 = value.token0 ?? value.currency0;
+  const token1 = value.token1 ?? value.currency1;
+  if (typeof token0 !== "string" || typeof token1 !== "string" || typeof value.hooks !== "string" || typeof value.fee !== "number" || typeof value.parameters !== "string") {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", "Router route poolKey has invalid fields", { poolKey });
+  }
+  return {
+    token0,
+    token1,
+    hooks: value.hooks,
+    fee: value.fee,
+    parameters: value.parameters
+  };
+}
+function normalizeRouteData(route) {
+  const poolKeysRaw = route.poolKeys;
+  if (!Array.isArray(poolKeysRaw)) {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", "Router route is missing poolKeys", { route });
+  }
+  return {
+    amountIn: requireString(route, "amountIn"),
+    amountInRaw: requireString(route, "amountInRaw"),
+    amountOut: requireString(route, "amountOut"),
+    amountOutRaw: requireString(route, "amountOutRaw"),
+    amountOutMinimum: typeof route.amountOutMinimum === "string" ? route.amountOutMinimum : "0",
+    amountOutMinimumRaw: typeof route.amountOutMinimumRaw === "string" ? route.amountOutMinimumRaw : "0",
+    inUsd: typeof route.inUsd === "string" ? route.inUsd : "0",
+    outUsd: typeof route.outUsd === "string" ? route.outUsd : "0",
+    impact: typeof route.impact === "string" ? route.impact : "0",
+    fee: typeof route.fee === "string" ? route.fee : "0",
+    containsUnverifiedHook: route.containsUnverifiedHook === true,
+    tokens: requireStringArray(route, "tokens"),
+    symbols: requireStringArray(route, "symbols"),
+    poolFees: requireStringArray(route, "poolFees"),
+    poolVersions: requireStringArray(route, "poolVersions"),
+    poolKeys: poolKeysRaw.map(normalizePoolKey),
+    stepAmountsOut: requireStringArray(route, "stepAmountsOut"),
+    ...typeof route.amountInReferralBips === "number" ? { amountInReferralBips: route.amountInReferralBips } : {},
+    ...typeof route.amountOutReferralBips === "number" ? { amountOutReferralBips: route.amountOutReferralBips } : {}
+  };
+}
+function routeStartsWithNativeTrx(chain, route) {
+  return route.tokens[0] === chain.contracts.trx;
+}
+function buildUniversalRouterSwapAction(input) {
+  const routeData = normalizeRouteData(input.route);
+  const hops = routeData.poolVersions.length;
+  if (hops === 0 || routeData.tokens.length !== hops + 1 || routeData.poolFees.length < hops || routeData.poolVersions.some((version) => !Object.values(import_universal_router_sdk.PoolVersion).includes(version))) {
+    throw new import_sun_sdk_core8.SDKError("SDK_INVALID_ARGUMENT", "Router route has inconsistent hop data");
+  }
+  routeData.tokens = routeData.tokens.map((token) => normalizeTronAddress(token));
+  const swapTradeRoute = (0, import_universal_router_sdk.parseRouteAPIResponse)(routeData, input.network === "nile", {
+    slippageBips: input.slippageBips
+  });
+  if (input.recipient) {
+    swapTradeRoute.recipient = new import_universal_router_sdk.Address(input.recipient);
+  }
+  const tradePlanner = new import_universal_router_sdk.TradePlanner([swapTradeRoute], false, {
+    permitOptions: input.permit ? { permitEnabled: true, permit: input.permit } : { permitEnabled: false }
+  });
+  tradePlanner.encode();
+  const usdtAddress = input.chain.contracts.usdt;
+  const sources = /* @__PURE__ */ new Map();
+  swapTradeRoute.pools.forEach((pool, index) => {
+    if (pool.type !== import_universal_router_sdk.PoolType.V3 || routeData.tokens[index + 1] !== usdtAddress) return;
+    const address = (0, import_sun_sdk_sunswap_v3.computeV3PoolAddress)({
+      network: input.network,
+      tokenA: routeData.tokens[index],
+      tokenB: usdtAddress,
+      fee: pool.fee,
+      factory: input.chain.contracts.sunswapV3Factory,
+      wrappedNative: input.chain.contracts.wtrx
+    });
+    sources.set(address, { address, role: "v3-pool" });
+  });
+  const usdtTransfer = {
+    network: input.network,
+    transfersUsdt: sources.size > 0,
+    sources: [...sources.values()]
+  };
+  return (0, import_sun_sdk_core8.createContractCallAction)({
+    id: "universal-router-swap",
+    target: input.chain.contracts.universalRouter,
+    functionSelector: "execute(bytes,bytes[],uint256)",
+    parameters: [
+      { type: "bytes", value: tradePlanner.commands },
+      { type: "bytes[]", value: tradePlanner.inputs },
+      { type: "uint256", value: input.deadline }
+    ],
+    ...routeStartsWithNativeTrx(input.chain, routeData) ? { callValue: BigInt(routeData.amountInRaw) } : {},
+    feeLimit: normalizeFeeLimit(input.feeLimit, DEFAULT_UNIVERSAL_ROUTER_SWAP_FEE_LIMIT),
+    metadata: { usdtTransfer }
+  });
+}
+
+// src/usdt-transfer.ts
+var import_sun_sdk_core9 = require("@sun-protocol/sun-sdk-core");
+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_core9.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/swap/router-execute.ts
+function signatureFromResults(actionId, completed) {
+  if (!actionId) return void 0;
+  const result = completed.find((item) => item.action.id === actionId)?.result;
+  return typeof result === "string" ? result.startsWith("0x") ? result : `0x${result}` : void 0;
+}
+async function materializeUniversalRouterActionWithSignature(context, action, permitSignature) {
+  if (action.materialization.kind !== UNIVERSAL_ROUTER_MATERIALIZATION_KIND) {
+    throw new import_sun_sdk_core10.SDKError("SDK_RUNTIME_ERROR", `Unsupported deferred action kind: ${action.materialization.kind}`);
+  }
+  const data = action.materialization.data;
+  if (data.network !== context.network) {
+    throw new import_sun_sdk_core10.SDKError("SDK_USDT_TRANSFER_UNKNOWN", "Network changed; rebuild the swap plan", { reason: "CHECK_FAILED" });
+  }
+  if (data.signatureActionId && !permitSignature) {
+    throw new import_sun_sdk_core10.SDKError("SDK_INVALID_ARGUMENT", "Router swap requires the planned Permit2 signature", {
+      actionId: action.id,
+      signatureActionId: data.signatureActionId
+    });
+  }
+  if (data.signatureActionId && !data.permitSingle) {
+    throw new import_sun_sdk_core10.SDKError("SDK_RUNTIME_ERROR", "Router swap plan is missing Permit2 permit data", {
+      actionId: action.id,
+      signatureActionId: data.signatureActionId
+    });
+  }
+  const normalizedSignature = permitSignature ? permitSignature.startsWith("0x") ? permitSignature : `0x${permitSignature}` : void 0;
+  const permit = normalizedSignature && data.permitSingle ? { ...data.permitSingle, signature: normalizedSignature } : void 0;
+  return buildUniversalRouterSwapAction({
+    network: context.network,
+    chain: context.chain,
+    route: data.route,
+    slippageBips: BigInt(data.slippageBips),
+    deadline: await resolveTransactionDeadline(context, data.transactionValidForSeconds),
+    ...data.recipient ? { recipient: data.recipient } : {},
+    ...permit ? { permit } : {},
+    ...data.feeLimit !== void 0 ? { feeLimit: data.feeLimit } : {}
+  });
+}
+async function materializeUniversalRouterAction(context, action, completedActions) {
+  const data = action.materialization.data;
+  const signature = signatureFromResults(data.signatureActionId, completedActions);
+  return materializeUniversalRouterActionWithSignature(context, action, signature);
+}
+function createRouterSwapExecutor(context, options) {
+  const executor = createContextExecutor(context);
+  return {
+    ...executor,
+    sendAction: async (action) => {
+      if (action.target === context.chain.contracts.universalRouter || action.intent?.scope.protocol === "universal-router" && action.intent.kind === "swap") {
+        await assertUsdtTransfer(context, action);
+      }
+      if (!executor.sendAction) throw new import_sun_sdk_core10.SDKError("SDK_RUNTIME_ERROR", "Swap execution requires a runtime");
+      return executor.sendAction(action);
+    },
+    materializeAction: (action, completed) => options ? materializeUniversalRouterActionWithSignature(context, action, options.permitSignature) : materializeUniversalRouterAction(context, action, completed)
+  };
+}
+
+// src/swap/plan.ts
+var import_sun_sdk_core17 = require("@sun-protocol/sun-sdk-core");
+
+// src/approval/permit2.ts
+var import_sun_sdk_core14 = require("@sun-protocol/sun-sdk-core");
+
+// src/internal/permit2-adapter.ts
+var import_sun_sdk_core11 = 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_core11.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_core11.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_core11.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_core11.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/plan.ts
+var import_sun_sdk_core13 = require("@sun-protocol/sun-sdk-core");
+
+// 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_core12 = require("@sun-protocol/sun-sdk-core");
+function buildClassicApproveAction(requirement, options = {}) {
+  if (requirement.asset.type === "native") return void 0;
+  return (0, import_sun_sdk_core12.createApproveAction)({
+    id: `approve-${requirement.asset.token}-${requirement.spender}`,
+    target: requirement.asset.token,
+    spender: requirement.spender,
+    amount: options.amount === "exact" ? requirement.amount : import_sun_sdk_core12.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_core13.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/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/swap/tokens.ts
+var import_sun_sdk_core15 = require("@sun-protocol/sun-sdk-core");
+function isNativeTrxToken(context, token) {
+  return token.toUpperCase() === "TRX" || token === context.chain.contracts.trx;
+}
+function normalizeRouterToken(context, token) {
+  return isNativeTrxToken(context, token) ? context.chain.contracts.trx : (0, import_sun_sdk_core15.assertTronAddress)(token, "token");
+}
+function normalizeV2TrxPairPath(context, input) {
+  const tokenInIsTrx = isNativeTrxToken(context, input.tokenIn);
+  const tokenOutIsTrx = isNativeTrxToken(context, input.tokenOut);
+  if (tokenInIsTrx === tokenOutIsTrx) {
+    throw new import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "V2 swap currently supports exactly one TRX side", {
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut
+    });
+  }
+  const token = (0, import_sun_sdk_core15.assertTronAddress)(tokenInIsTrx ? input.tokenOut : input.tokenIn, "token");
+  return tokenInIsTrx ? { direction: "trx-to-token", token, path: [context.chain.contracts.wtrx, token] } : { direction: "token-to-trx", token, path: [token, context.chain.contracts.wtrx] };
+}
+function normalizeV2PathToken(context, token, label) {
+  if (isNativeTrxToken(context, token) || token === context.chain.contracts.wtrx) {
+    return context.chain.contracts.wtrx;
+  }
+  return (0, import_sun_sdk_core15.assertTronAddress)(token, label);
+}
+function isWrappedTrxToken(context, token) {
+  return token === context.chain.contracts.wtrx;
+}
+function detectWtrxSwap(context, input) {
+  const amountIn = normalizeBaseUnitAmount(input.amountIn, "amountIn");
+  const tokenInIsTrx = isNativeTrxToken(context, input.tokenIn);
+  const tokenOutIsTrx = isNativeTrxToken(context, input.tokenOut);
+  const tokenInIsWtrx = isWrappedTrxToken(context, input.tokenIn);
+  const tokenOutIsWtrx = isWrappedTrxToken(context, input.tokenOut);
+  let action;
+  if (tokenInIsTrx && tokenOutIsWtrx) action = "wrap";
+  if (tokenInIsWtrx && tokenOutIsTrx) action = "unwrap";
+  if (!action) return void 0;
+  return {
+    kind: "wtrx",
+    source: "wtrx",
+    action,
+    tokenIn: input.tokenIn,
+    tokenOut: input.tokenOut,
+    amountIn,
+    amountOut: amountIn,
+    route: {
+      type: action === "wrap" ? "WTRX_WRAP" : "WTRX_UNWRAP",
+      amountIn,
+      amountOut: amountIn
+    }
+  };
+}
+function normalizeV2SwapPath(context, input) {
+  const tokenInIsTrx = isNativeTrxToken(context, input.tokenIn);
+  const tokenOutIsTrx = isNativeTrxToken(context, input.tokenOut);
+  const tokenInIsWtrx = isWrappedTrxToken(context, input.tokenIn);
+  const tokenOutIsWtrx = isWrappedTrxToken(context, input.tokenOut);
+  if (tokenInIsTrx && (tokenOutIsTrx || tokenOutIsWtrx) || tokenInIsWtrx && tokenOutIsTrx) {
+    throw new import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "V2 swap does not handle TRX wrap or unwrap", {
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut
+    });
+  }
+  const inputToken = normalizeV2PathToken(context, input.tokenIn, "tokenIn");
+  const outputToken = normalizeV2PathToken(context, input.tokenOut, "tokenOut");
+  const path = (input.path ?? [input.tokenIn, input.tokenOut]).map(
+    (token, index) => normalizeV2PathToken(context, token, `path[${index}]`)
+  );
+  const originalPath = input.path ?? [input.tokenIn, input.tokenOut];
+  if (inputToken === outputToken) {
+    throw new import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "V2 swap tokenIn and tokenOut must differ", {
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut
+    });
+  }
+  if (path.length < 2 || path[0] !== inputToken || path[path.length - 1] !== outputToken) {
+    throw new import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "V2 swap path must start with tokenIn and end with tokenOut", {
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut,
+      path: originalPath
+    });
+  }
+  if (path.some((token, index) => index > 0 && token === path[index - 1])) {
+    throw new import_sun_sdk_core15.SDKError("SDK_INVALID_ARGUMENT", "V2 swap path must not contain duplicate adjacent tokens", {
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut,
+      path: originalPath
+    });
+  }
+  const direction = tokenInIsTrx ? "trx-to-token" : tokenOutIsTrx ? "token-to-trx" : "token-to-token";
+  return { direction, token: tokenInIsTrx ? outputToken : inputToken, path };
+}
+
+// src/swap/intents.ts
+var import_sun_sdk_core16 = require("@sun-protocol/sun-sdk-core");
+
+// 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/swap/intents.ts
+var UNIVERSAL_ROUTER_PROTOCOL_ID = "universal-router";
+var PSM_PROTOCOL_ID = "psm";
+var WTRX_PROTOCOL_ID = "wtrx";
+function swapIntentScope(protocol, operation) {
+  return {
+    domain: "swap",
+    protocol,
+    ...operation === void 0 ? {} : { operation }
+  };
+}
+function routerRouteSymbols(route) {
+  const symbols = route.symbols;
+  if (!Array.isArray(symbols) || symbols.length < 2 || symbols.some((symbol) => typeof symbol !== "string" || symbol.length === 0)) {
+    throw new import_sun_sdk_core16.SDKError("SDK_API_ERROR", "Selected Router route is missing token symbols");
+  }
+  return {
+    from: symbols[0],
+    to: symbols[symbols.length - 1]
+  };
+}
+
+// src/swap/plan.ts
+function stringifyRoute(route) {
+  try {
+    return JSON.stringify(route);
+  } catch {
+    return void 0;
+  }
+}
+function findSelectedRouteIndex(quote, route) {
+  const serializedRoute = stringifyRoute(route);
+  return quote.routes.findIndex((candidate) => {
+    if (candidate === route) return true;
+    if (serializedRoute === void 0) return false;
+    return stringifyRoute(candidate) === serializedRoute;
+  });
+}
+function isWtrxRoute(route) {
+  return typeof route === "object" && route !== null && (route.type === "WTRX_WRAP" || route.type === "WTRX_UNWRAP");
+}
+function buildWtrxSwapPlan(context, quote, route, owner, feeLimit) {
+  if (stringifyRoute(route) !== stringifyRoute(quote.route)) {
+    throw new import_sun_sdk_core17.SDKError("SDK_INVALID_ARGUMENT", "Selected WTRX route must come from the quote", {
+      quoteRoute: quote.route,
+      route
+    });
+  }
+  const resolvedFeeLimit = normalizeFeeLimit(feeLimit, DEFAULT_WTRX_SWAP_FEE_LIMIT);
+  const intent = {
+    kind: quote.action,
+    scope: swapIntentScope(WTRX_PROTOCOL_ID, quote.action),
+    amount: (0, import_sun_sdk_core17.formatUnits)(BigInt(quote.amountIn), context.chain.nativeCurrency.decimals)
+  };
+  const transaction = quote.action === "wrap" ? (0, import_sun_sdk_core17.createContractCallAction)({
+    id: `${nextPlanId(context, "swap-wtrx")}-wrap`,
+    target: context.chain.contracts.wtrx,
+    functionSelector: "deposit()",
+    parameters: [],
+    callValue: BigInt(quote.amountIn),
+    feeLimit: resolvedFeeLimit,
+    intent
+  }) : (0, import_sun_sdk_core17.createContractCallAction)({
+    id: `${nextPlanId(context, "swap-wtrx")}-unwrap`,
+    target: context.chain.contracts.wtrx,
+    functionSelector: "withdraw(uint256)",
+    parameters: [{ type: "uint256", value: quote.amountIn }],
+    feeLimit: resolvedFeeLimit,
+    intent
+  });
+  return {
+    id: nextPlanId(context, "swap-wtrx"),
+    kind: "swap",
+    network: context.network,
+    owner,
+    summary: {
+      title: quote.action === "wrap" ? "Wrap TRX" : "Unwrap WTRX",
+      lines: [`Amount ${quote.amountIn}`]
+    },
+    approvals: [],
+    transactions: [transaction],
+    metadata: {
+      protocol: "wtrx",
+      action: quote.action,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      tokenIn: quote.tokenIn,
+      tokenOut: quote.tokenOut,
+      feeLimit: resolvedFeeLimit
+    }
+  };
+}
+async function planRouterSwap(context, input) {
+  const { wallet, address: owner } = await requireWalletSnapshot(context, "Router swap plan");
+  if (input.quote.kind === "wtrx") {
+    if (!isWtrxRoute(input.route)) {
+      throw new import_sun_sdk_core17.SDKError("SDK_INVALID_ARGUMENT", "WTRX swap planning requires a WTRX route");
+    }
+    return buildWtrxSwapPlan(context, input.quote, input.route, owner, input.feeLimit);
+  }
+  const selectedRouteIndex = findSelectedRouteIndex(input.quote, input.route);
+  if (selectedRouteIndex < 0) {
+    throw new import_sun_sdk_core17.SDKError("SDK_INVALID_ARGUMENT", "Selected route must come from quote.routes", {
+      routeCount: input.quote.routes.length,
+      tokenIn: input.quote.tokenIn,
+      tokenOut: input.quote.tokenOut,
+      amountIn: input.quote.amountIn
+    });
+  }
+  const selectedRoute = input.quote.routes[selectedRouteIndex];
+  if (!selectedRoute) {
+    throw new import_sun_sdk_core17.SDKError("SDK_RUNTIME_ERROR", "Selected router route could not be resolved after validation", {
+      selectedRouteIndex,
+      routeCount: input.quote.routes.length
+    });
+  }
+  const symbols = routerRouteSymbols(selectedRoute);
+  const intentScope = swapIntentScope(UNIVERSAL_ROUTER_PROTOCOL_ID);
+  const recipient = await normalizeRecipient(context, input.recipient, "Router swap recipient", owner);
+  const transactionValidForSeconds = normalizeTransactionValidForSeconds(input.transactionValidForSeconds);
+  const slippageBips = slippageToBips(input.slippage ?? "0.5%");
+  const feeLimit = normalizeFeeLimit(input.feeLimit, DEFAULT_UNIVERSAL_ROUTER_SWAP_FEE_LIMIT);
+  const tokenIn = input.quote.tokenIn;
+  const approvals = [];
+  let signatureActionId;
+  let permitSingle;
+  if (!isNativeTrxToken(context, tokenIn)) {
+    const authorization = await planRouterPermit2Authorization(context, {
+      owner,
+      token: (0, import_sun_sdk_core17.assertTronAddress)(tokenIn, "tokenIn"),
+      amount: input.quote.amountIn,
+      approval: input.approval ?? "auto",
+      approveAmountType: "max",
+      walletCapabilities: wallet.capabilities
+    });
+    approvals.push(...attachApprovalIntent(authorization.actions, intentScope, symbols.from));
+    signatureActionId = authorization.signatureActionId;
+    permitSingle = authorization.permitSingle;
+  }
+  const transaction = createUniversalRouterDeferredAction({
+    id: `${nextPlanId(context, "swap-router")}-execute`,
+    data: {
+      network: context.network,
+      route: selectedRoute,
+      slippageBips: slippageBips.toString(),
+      transactionValidForSeconds,
+      recipient,
+      feeLimit,
+      ...signatureActionId ? { signatureActionId } : {},
+      ...permitSingle ? { permitSingle } : {}
+    },
+    intent: {
+      kind: "swap",
+      scope: intentScope,
+      from: { value: selectedRoute.amountIn, symbol: symbols.from },
+      to: { value: selectedRoute.amountOut, symbol: symbols.to },
+      ...input.recipient === void 0 ? {} : { recipient }
+    }
+  });
+  return {
+    id: nextPlanId(context, "swap-router"),
+    kind: "swap",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Swap with Universal Router",
+      lines: [`Spend ${selectedRoute.amountIn}`, `Expected output ${selectedRoute.amountOut}`]
+    },
+    approvals,
+    transactions: [transaction],
+    metadata: {
+      protocol: "universal-router",
+      selectedRouteIndex,
+      tokenIn: input.quote.tokenIn,
+      tokenOut: input.quote.tokenOut,
+      amountIn: selectedRoute.amountInRaw,
+      amountOut: selectedRoute.amountOutRaw,
+      amountInFormatted: selectedRoute.amountIn,
+      amountOutFormatted: selectedRoute.amountOut,
+      slippageBips,
+      recipient,
+      transactionValidForSeconds,
+      feeLimit
+    }
+  };
+}
+
+// src/swap/quote.ts
+var import_sun_sdk_core18 = require("@sun-protocol/sun-sdk-core");
+function requireRoutes(response) {
+  if (response.code !== 0) {
+    throw new import_sun_sdk_core18.SDKError("SDK_NO_ROUTE", response.message ?? "Router API returned no route", {
+      code: response.code,
+      message: response.message
+    });
+  }
+  if (!Array.isArray(response.data) || response.data.length === 0) {
+    throw new import_sun_sdk_core18.SDKError("SDK_NO_ROUTE", "Router API returned no route", {
+      code: response.code
+    });
+  }
+  return response.data;
+}
+function normalizeRouteTypeList(input) {
+  if (input.routerRouteTypes !== void 0 && input.typeList !== void 0) {
+    throw new import_sun_sdk_core18.SDKError("SDK_INVALID_ARGUMENT", "Use routerRouteTypes or typeList, not both", {
+      routerRouteTypes: input.routerRouteTypes,
+      typeList: input.typeList
+    });
+  }
+  return input.routerRouteTypes !== void 0 ? input.routerRouteTypes.join(",") : input.typeList;
+}
+function requireRouterAmountString(route, field, routeIndex) {
+  const value = route[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new import_sun_sdk_core18.SDKError("SDK_API_ERROR", `Router route has invalid ${field}`, {
+      routeIndex,
+      field,
+      value
+    });
+  }
+  return value;
+}
+function normalizeRouterRawAmount(value, field, routeIndex) {
+  try {
+    return normalizeBaseUnitAmount(value, `Router route ${field}`);
+  } catch {
+    throw new import_sun_sdk_core18.SDKError("SDK_API_ERROR", `Router route has invalid ${field}`, {
+      routeIndex,
+      field,
+      value
+    });
+  }
+}
+function validateRouterRoute(route, routeIndex, requestedAmountIn) {
+  if (typeof route !== "object" || route === null || Array.isArray(route)) {
+    throw new import_sun_sdk_core18.SDKError("SDK_API_ERROR", "Router route must be an object", {
+      routeIndex,
+      route
+    });
+  }
+  const routeRecord = route;
+  const amountIn = requireRouterAmountString(routeRecord, "amountIn", routeIndex);
+  const amountOut = requireRouterAmountString(routeRecord, "amountOut", routeIndex);
+  const amountInRaw = normalizeRouterRawAmount(
+    requireRouterAmountString(routeRecord, "amountInRaw", routeIndex),
+    "amountInRaw",
+    routeIndex
+  );
+  const amountOutRaw = normalizeRouterRawAmount(
+    requireRouterAmountString(routeRecord, "amountOutRaw", routeIndex),
+    "amountOutRaw",
+    routeIndex
+  );
+  if (amountInRaw !== requestedAmountIn) {
+    throw new import_sun_sdk_core18.SDKError("SDK_API_ERROR", "Router route input amount does not match the request", {
+      routeIndex,
+      requestedAmountIn,
+      routeAmountInRaw: amountInRaw
+    });
+  }
+  return {
+    ...routeRecord,
+    amountIn,
+    amountInRaw,
+    amountOut,
+    amountOutRaw
+  };
+}
+async function quoteRouterSwap(context, input) {
+  const wtrxQuote = detectWtrxSwap(context, input);
+  if (wtrxQuote) return wtrxQuote;
+  const amountIn = normalizeBaseUnitAmount(input.amountIn, "amountIn");
+  const typeList = normalizeRouteTypeList(input);
+  const routerEndpoint = context.endpoints.router;
+  if (!routerEndpoint) {
+    throw new import_sun_sdk_core18.SDKError("SDK_UNSUPPORTED_NETWORK", "Router API endpoint is not configured for this network", {
+      network: context.network
+    });
+  }
+  const routesResponse = await context.routerApi.getRoutes(routerEndpoint, {
+    fromToken: normalizeRouterToken(context, input.tokenIn),
+    toToken: normalizeRouterToken(context, input.tokenOut),
+    amountIn,
+    ...typeList !== void 0 ? { typeList } : {},
+    ...input.includeUnverifiedV4Hook !== void 0 ? { includeUnverifiedV4Hook: input.includeUnverifiedV4Hook } : {}
+  });
+  const routes = requireRoutes(routesResponse).map((route, routeIndex) => validateRouterRoute(route, routeIndex, amountIn));
+  const bestRoute = routes[0];
+  if (!bestRoute) {
+    throw new import_sun_sdk_core18.SDKError("SDK_NO_ROUTE", "Router API returned no route");
+  }
+  return {
+    kind: "router",
+    source: "router",
+    tokenIn: input.tokenIn,
+    tokenOut: input.tokenOut,
+    amountIn: bestRoute.amountInRaw,
+    amountOut: bestRoute.amountOutRaw,
+    amountInFormatted: bestRoute.amountIn,
+    amountOutFormatted: bestRoute.amountOut,
+    routes,
+    bestRoute
+  };
+}
+var quoteSwap = quoteRouterSwap;
+
+// src/swap/workflow.ts
+var import_sun_sdk_core19 = require("@sun-protocol/sun-sdk-core");
+function assertSwapPlan(plan, protocols, clientName) {
+  const protocol = plan.metadata.protocol;
+  if (plan.kind !== "swap" || typeof protocol !== "string" || !protocols.includes(protocol) || plan.transactions.length === 0) {
+    throw new import_sun_sdk_core19.SDKError("SDK_INVALID_ARGUMENT", `Expected a ${clientName} swap plan`, {
+      planId: plan.id,
+      kind: plan.kind,
+      protocol,
+      transactionCount: plan.transactions.length
+    });
+  }
+}
+
+// src/swap/router.ts
+var SwapRouterClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  quote(input) {
+    return quoteRouterSwap(this.context, input);
+  }
+  plan(input) {
+    return planRouterSwap(this.context, input);
+  }
+  executeAction(action) {
+    return executePlanAction(action, createRouterSwapExecutor(this.context));
+  }
+  async submit(plan, options = {}) {
+    assertSwapPlan(plan, ["universal-router", "wtrx"], "Router");
+    return executePlanTransactions(
+      plan,
+      createRouterSwapExecutor(this.context, options)
+    );
+  }
+  async execute(input) {
+    const plan = isTransactionPlan(input) ? input : await planRouterSwap(this.context, input);
+    assertSwapPlan(plan, ["universal-router", "wtrx"], "Router");
+    return executeTransactionPlan(plan, createRouterSwapExecutor(this.context));
+  }
+};
+function createSwapRouterClient(options) {
+  return new SwapRouterClient(createProtocolsContext(options));
+}
+
+// src/internal/v2-swap-action.ts
+var import_sun_sdk_sunswap_v22 = require("@sun-protocol/sun-sdk-sunswap-v2");
+var import_sun_sdk_core20 = require("@sun-protocol/sun-sdk-core");
+var V2_SWAP_MATERIALIZATION_KIND = "sunswap-v2-swap";
+function requireAmount(data, key) {
+  const value = data[key];
+  if (value === void 0) {
+    throw new import_sun_sdk_core20.SDKError("SDK_RUNTIME_ERROR", `Deferred V2 swap is missing ${key}`, {
+      operation: data.operation,
+      key
+    });
+  }
+  return value;
+}
+function createDeferredV2SwapAction(input) {
+  return (0, import_sun_sdk_core20.createDeferredContractCallAction)({
+    id: `sunswap-v2-${input.data.operation}`,
+    materialization: {
+      kind: V2_SWAP_MATERIALIZATION_KIND,
+      data: input.data
+    }
+  });
+}
+async function materializeV2SwapAction(context, action) {
+  if (action.materialization.kind !== V2_SWAP_MATERIALIZATION_KIND) {
+    throw new import_sun_sdk_core20.SDKError("SDK_RUNTIME_ERROR", `Unsupported deferred action kind: ${action.materialization.kind}`);
+  }
+  const data = action.materialization.data;
+  const options = {
+    network: context.network,
+    id: action.id,
+    path: data.path,
+    recipient: data.recipient,
+    deadline: await resolveTransactionDeadline(context, data.transactionValidForSeconds)
+  };
+  switch (data.operation) {
+    case "swap-exact-eth-for-tokens":
+      return (0, import_sun_sdk_sunswap_v22.buildV2SwapExactEthForTokensAction)({
+        ...options,
+        amountIn: requireAmount(data, "amountIn"),
+        amountOutMin: requireAmount(data, "amountOutMin")
+      });
+    case "swap-eth-for-exact-tokens":
+      return (0, import_sun_sdk_sunswap_v22.buildV2SwapEthForExactTokensAction)({
+        ...options,
+        amountOut: requireAmount(data, "amountOut"),
+        amountInMax: requireAmount(data, "amountInMax")
+      });
+    case "swap-exact-tokens-for-eth":
+      return (0, import_sun_sdk_sunswap_v22.buildV2SwapExactTokensForEthAction)({
+        ...options,
+        amountIn: requireAmount(data, "amountIn"),
+        amountOutMin: requireAmount(data, "amountOutMin")
+      });
+    case "swap-exact-tokens-for-tokens":
+      return (0, import_sun_sdk_sunswap_v22.buildV2SwapExactTokensForTokensAction)({
+        ...options,
+        amountIn: requireAmount(data, "amountIn"),
+        amountOutMin: requireAmount(data, "amountOutMin")
+      });
+    case "swap-tokens-for-exact-eth":
+      return (0, import_sun_sdk_sunswap_v22.buildV2SwapTokensForExactEthAction)({
+        ...options,
+        amountOut: requireAmount(data, "amountOut"),
+        amountInMax: requireAmount(data, "amountInMax")
+      });
+    case "swap-tokens-for-exact-tokens":
+      return (0, import_sun_sdk_sunswap_v22.buildV2SwapTokensForExactTokensAction)({
+        ...options,
+        amountOut: requireAmount(data, "amountOut"),
+        amountInMax: requireAmount(data, "amountInMax")
+      });
+  }
+}
+
+// src/swap/v2-execute.ts
+function createV2SwapExecutor(context) {
+  return {
+    ...createContextExecutor(context),
+    materializeAction: (action) => materializeV2SwapAction(context, action)
+  };
+}
+
+// src/swap/psm.ts
+var import_sun_sdk_psm = require("@sun-protocol/sun-sdk-psm");
+var import_sun_sdk_core22 = require("@sun-protocol/sun-sdk-core");
+
+// src/internal/reads.ts
+var import_sun_sdk_core21 = 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_core21.SDKError("SDK_CONTRACT_ERROR", `${operation} returned an empty result`, { call });
+  }
+  return value;
+}
+
+// src/swap/psm.ts
+function normalizePsmApprovalMode(value) {
+  if (value === void 0) return "auto";
+  if (value === "auto" || value === "approve" || value === "none") return value;
+  throw new import_sun_sdk_core22.SDKError("SDK_INVALID_ARGUMENT", "unsupported PSM approval mode", {
+    approval: value
+  });
+}
+function resolvePsmContracts(context, overrides) {
+  return {
+    psmUsdt: resolveProtocolContract(context, overrides, "psmUsdt"),
+    psmUsdd: resolveProtocolContract(context, overrides, "psmUsdd"),
+    psm: resolveProtocolContract(context, overrides, "psm"),
+    psmGemJoin: resolveProtocolContract(context, overrides, "psmGemJoin"),
+    psmInfoReader: resolveProtocolContract(context, overrides, "psmInfoReader")
+  };
+}
+function invalidAmountShape(mode) {
+  throw new import_sun_sdk_core22.SDKError(
+    "SDK_INVALID_ARGUMENT",
+    mode === "exact-in" ? "exact-in PSM swap requires only amountIn" : "exact-out PSM swap requires only amountOut",
+    { mode }
+  );
+}
+function normalizeSpecifiedAmount(value, label) {
+  if (typeof value !== "string") {
+    throw new import_sun_sdk_core22.SDKError("SDK_INVALID_ARGUMENT", `${label} must be a string`, {
+      [label]: value
+    });
+  }
+  return normalizeBaseUnitAmount(value, label);
+}
+function normalizeQuoteInput(context, input) {
+  const mode = input.mode ?? "exact-in";
+  let specifiedAmount;
+  if (mode === "exact-in") {
+    if (input.amountIn === void 0 || input.amountOut !== void 0) return invalidAmountShape(mode);
+    specifiedAmount = normalizeSpecifiedAmount(input.amountIn, "amountIn");
+  } else if (mode === "exact-out") {
+    if (input.amountOut === void 0 || input.amountIn !== void 0) return invalidAmountShape(mode);
+    specifiedAmount = normalizeSpecifiedAmount(input.amountOut, "amountOut");
+  } else {
+    throw new import_sun_sdk_core22.SDKError("SDK_INVALID_ARGUMENT", "unsupported PSM quote mode", { mode });
+  }
+  const tokenIn = (0, import_sun_sdk_core22.assertTronAddress)(input.tokenIn, "tokenIn");
+  const tokenOut = (0, import_sun_sdk_core22.assertTronAddress)(input.tokenOut, "tokenOut");
+  const { psmUsdt, psmUsdd } = resolvePsmContracts(context, input.contracts);
+  let direction;
+  if (tokenIn === psmUsdt && tokenOut === psmUsdd) {
+    direction = "usdt-to-usdd";
+  } else if (tokenIn === psmUsdd && tokenOut === psmUsdt) {
+    direction = "usdd-to-usdt";
+  } else {
+    throw new import_sun_sdk_core22.SDKError("SDK_INVALID_ARGUMENT", "PSM swap only supports its configured USDT/USDD pair", {
+      tokenIn,
+      tokenOut,
+      psmUsdt,
+      psmUsdd
+    });
+  }
+  return { mode, direction, specifiedAmount, tokenIn, tokenOut };
+}
+async function readPsm(context, input = {}) {
+  const contracts = resolvePsmContracts(context, input.contracts);
+  const result = await readRequiredContract(
+    context,
+    (0, import_sun_sdk_psm.buildPsmInfoRead)({
+      network: context.network,
+      psm: contracts.psm,
+      infoReader: contracts.psmInfoReader
+    }),
+    "PSM info read"
+  );
+  return (0, import_sun_sdk_psm.createPsmSnapshot)((0, import_sun_sdk_psm.normalizePsmInfoResult)(result));
+}
+async function quotePsmSwap(context, input) {
+  const normalized = normalizeQuoteInput(context, input);
+  const snapshot = await readPsm(context, input);
+  return {
+    ...(0, import_sun_sdk_psm.quotePsm)({
+      mode: normalized.mode,
+      direction: normalized.direction,
+      specifiedAmount: normalized.specifiedAmount,
+      snapshot
+    }),
+    kind: "psm",
+    source: "psm",
+    tokenIn: normalized.tokenIn,
+    tokenOut: normalized.tokenOut
+  };
+}
+async function planPsmSwap(context, input) {
+  const { address: owner } = await requireWalletSnapshot(context, "PSM swap plan");
+  const feeLimit = normalizeFeeLimit(input.feeLimit, DEFAULT_PSM_SWAP_FEE_LIMIT);
+  const quote = await quotePsmSwap(context, input);
+  const recipient = input.recipient !== void 0 ? (0, import_sun_sdk_core22.assertTronAddress)(input.recipient, "PSM recipient") : owner;
+  const contracts = resolvePsmContracts(context, input.contracts);
+  const tokenIn = quote.direction === "usdt-to-usdd" ? contracts.psmUsdt : contracts.psmUsdd;
+  const spender = quote.direction === "usdt-to-usdd" ? contracts.psmGemJoin : contracts.psm;
+  const approvalMode = normalizePsmApprovalMode(input.approval);
+  const approval = await planApproval(context, {
+    asset: { type: "token", token: tokenIn },
+    owner,
+    spender,
+    amount: quote.amountIn
+  }, {
+    mode: approvalMode,
+    amount: "max",
+    feeLimit: DEFAULT_PSM_APPROVAL_FEE_LIMIT
+  });
+  const inputSymbol = quote.direction === "usdt-to-usdd" ? "USDT" : "USDD";
+  const outputSymbol = quote.direction === "usdt-to-usdd" ? "USDD" : "USDT";
+  const inputDecimals = quote.direction === "usdt-to-usdd" ? 6 : 18;
+  const outputDecimals = quote.direction === "usdt-to-usdd" ? 18 : 6;
+  const intentScope = swapIntentScope(PSM_PROTOCOL_ID, quote.direction);
+  const planId = nextPlanId(context, "swap-psm");
+  const actionOptions = {
+    network: context.network,
+    psm: contracts.psm,
+    recipient,
+    gemAmount: quote.gemAmount,
+    feeLimit,
+    id: `${planId}-swap`
+  };
+  const transactionAction = quote.direction === "usdt-to-usdd" ? (0, import_sun_sdk_psm.buildPsmSellGemAction)(actionOptions) : (0, import_sun_sdk_psm.buildPsmBuyGemAction)(actionOptions);
+  const transaction = {
+    ...transactionAction,
+    intent: {
+      kind: "swap",
+      scope: intentScope,
+      from: { value: (0, import_sun_sdk_core22.formatUnits)(BigInt(quote.amountIn), inputDecimals), symbol: inputSymbol },
+      to: { value: (0, import_sun_sdk_core22.formatUnits)(BigInt(quote.amountOut), outputDecimals), symbol: outputSymbol },
+      ...input.recipient === void 0 ? {} : { recipient }
+    }
+  };
+  return {
+    id: planId,
+    kind: "swap",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Swap with PSM",
+      lines: [
+        `Spend ${quote.amountIn} token units`,
+        `Receive ${quote.amountOut} token units`
+      ]
+    },
+    approvals: attachApprovalIntent(approval.actions, intentScope, inputSymbol),
+    transactions: [transaction],
+    metadata: {
+      protocol: "psm",
+      mode: quote.mode,
+      direction: quote.direction,
+      amountIn: quote.amountIn,
+      amountOut: quote.amountOut,
+      specifiedAmount: quote.specifiedAmount,
+      gemAmount: quote.gemAmount,
+      feeAmount: quote.feeAmount,
+      feeRate: quote.feeRate,
+      availableAmountOut: quote.availableAmountOut,
+      owner,
+      recipient,
+      spender,
+      approvalMode
+    }
+  };
+}
+var PsmSwapClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  read(input = {}) {
+    return readPsm(this.context, input);
+  }
+  quote(input) {
+    return quotePsmSwap(this.context, input);
+  }
+  plan(input) {
+    return planPsmSwap(this.context, input);
+  }
+  executeAction(action) {
+    return executePlanAction(action, createContextExecutor(this.context));
+  }
+  submit(plan) {
+    assertSwapPlan(plan, ["psm"], "PSM");
+    return executePlanTransactions(plan, createContextExecutor(this.context));
+  }
+  async execute(input) {
+    const plan = isTransactionPlan(input) ? input : await planPsmSwap(this.context, input);
+    assertSwapPlan(plan, ["psm"], "PSM");
+    return executeTransactionPlan(plan, createContextExecutor(this.context));
+  }
+};
+function createPsmSwapClient(context) {
+  return new PsmSwapClient(context);
+}
+function createPsmClient(options) {
+  return createPsmSwapClient(createProtocolsContext(options));
+}
+
+// src/swap/v2.ts
+var import_sun_sdk_sunswap_v23 = require("@sun-protocol/sun-sdk-sunswap-v2");
+var import_sun_sdk_core23 = require("@sun-protocol/sun-sdk-core");
+function normalizeV2Mode(input) {
+  const mode = input.mode ?? "exact-in";
+  if (mode === "exact-in") {
+    normalizeBaseUnitAmount(input.amountIn ?? "", "amountIn");
+    if (input.amountOut !== void 0) {
+      throw new import_sun_sdk_core23.SDKError("SDK_INVALID_ARGUMENT", "exact-in V2 swap does not accept amountOut");
+    }
+    return mode;
+  }
+  normalizeBaseUnitAmount(input.amountOut ?? "", "amountOut");
+  if (input.amountIn !== void 0) {
+    throw new import_sun_sdk_core23.SDKError("SDK_INVALID_ARGUMENT", "exact-out V2 swap does not accept amountIn");
+  }
+  return mode;
+}
+function requireAmount2(amounts, index, operation) {
+  const amount = amounts[index];
+  if (amount === void 0) {
+    throw new import_sun_sdk_core23.SDKError("SDK_CONTRACT_ERROR", "V2 router returned an incomplete amount path", {
+      operation,
+      amounts
+    });
+  }
+  return amount;
+}
+function requireAmountPath(amounts, path, operation) {
+  if (amounts.length !== path.length) {
+    throw new import_sun_sdk_core23.SDKError("SDK_CONTRACT_ERROR", "V2 router returned an incomplete amount path", {
+      operation,
+      amounts,
+      path
+    });
+  }
+}
+function normalizeAllowedTradingPairResult(result) {
+  if (typeof result === "boolean") return result;
+  if (Array.isArray(result) && typeof result[0] === "boolean") return result[0];
+  return Boolean(result);
+}
+async function assertV2PathAllowed(context, path) {
+  const runtime = requireRuntime(context, "V2 allowed trading pair check");
+  for (let index = 0; index < path.length - 1; index += 1) {
+    const tokenA = (0, import_sun_sdk_core23.assertTronAddress)(path[index] ?? "", `path[${index}]`);
+    const tokenB = (0, import_sun_sdk_core23.assertTronAddress)(path[index + 1] ?? "", `path[${index + 1}]`);
+    const allowed = normalizeAllowedTradingPairResult(await runtime.readContract((0, import_sun_sdk_sunswap_v23.buildV2RouterAllowedTradingPairRead)({
+      network: context.network,
+      tokenA,
+      tokenB
+    })));
+    if (!allowed) {
+      throw new import_sun_sdk_core23.SDKError("SDK_NO_ROUTE", "SunSwap V2 router does not allow this trading pair", {
+        operation: "v2-allowed-trading-pair-check",
+        blockedPair: [tokenA, tokenB],
+        path
+      });
+    }
+  }
+}
+async function quoteV2Swap(context, input) {
+  const runtime = requireRuntime(context, "V2 swap quote");
+  const mode = normalizeV2Mode(input);
+  const pathInfo = normalizeV2SwapPath(context, input);
+  await assertV2PathAllowed(context, pathInfo.path);
+  if (mode === "exact-in") {
+    const amountIn = normalizeBaseUnitAmount(input.amountIn ?? "", "amountIn");
+    const amounts2 = (0, import_sun_sdk_sunswap_v23.normalizeV2AmountsResult)(await runtime.readContract((0, import_sun_sdk_sunswap_v23.buildV2RouterAmountsOutRead)({
+      network: context.network,
+      amountIn,
+      path: pathInfo.path
+    })));
+    requireAmountPath(amounts2, pathInfo.path, "v2-exact-in-quote");
+    return {
+      kind: "v2",
+      source: "v2",
+      mode,
+      direction: pathInfo.direction,
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut,
+      amountIn,
+      amountOut: requireAmount2(amounts2, amounts2.length - 1, "v2-exact-in-quote"),
+      path: pathInfo.path
+    };
+  }
+  const amountOut = normalizeBaseUnitAmount(input.amountOut ?? "", "amountOut");
+  const amounts = (0, import_sun_sdk_sunswap_v23.normalizeV2AmountsResult)(await runtime.readContract((0, import_sun_sdk_sunswap_v23.buildV2RouterAmountsInRead)({
+    network: context.network,
+    amountOut,
+    path: pathInfo.path
+  })));
+  requireAmountPath(amounts, pathInfo.path, "v2-exact-out-quote");
+  return {
+    kind: "v2",
+    source: "v2",
+    mode,
+    direction: pathInfo.direction,
+    tokenIn: input.tokenIn,
+    tokenOut: input.tokenOut,
+    amountIn: requireAmount2(amounts, 0, "v2-exact-out-quote"),
+    amountOut,
+    path: pathInfo.path
+  };
+}
+async function planV2Swap(context, input) {
+  const { address: owner } = await requireWalletSnapshot(context, "V2 swap plan");
+  const quote = await quoteV2Swap(context, input);
+  const recipient = await normalizeRecipient(context, input.recipient, "V2 swap recipient", owner);
+  const transactionValidForSeconds = normalizeTransactionValidForSeconds(input.transactionValidForSeconds);
+  const slippageBips = slippageToBips(input.slippage ?? "0.5%");
+  const approvals = [];
+  if (quote.mode === "exact-in" && quote.direction === "trx-to-token") {
+    const minAmountOut = applySlippageMin(BigInt(quote.amountOut), slippageBips).toString();
+    const transaction2 = createDeferredV2SwapAction({
+      data: {
+        operation: "swap-exact-eth-for-tokens",
+        amountIn: quote.amountIn,
+        amountOutMin: minAmountOut,
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds
+      }
+    });
+    return {
+      id: nextPlanId(context, "swap-v2"),
+      kind: "swap",
+      network: context.network,
+      owner,
+      summary: {
+        title: "Swap with SunSwap V2",
+        lines: [`Spend ${quote.amountIn} sun`, `Receive at least ${minAmountOut} token units`]
+      },
+      approvals,
+      transactions: [transaction2],
+      metadata: {
+        protocol: "sunswap-v2",
+        mode: quote.mode,
+        direction: quote.direction,
+        amountIn: quote.amountIn,
+        quotedAmountOut: quote.amountOut,
+        minAmountOut,
+        slippageBips,
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds
+      }
+    };
+  }
+  if (quote.mode === "exact-out" && quote.direction === "trx-to-token") {
+    const maxAmountIn2 = applySlippageMax(BigInt(quote.amountIn), slippageBips).toString();
+    const transaction2 = createDeferredV2SwapAction({
+      data: {
+        operation: "swap-eth-for-exact-tokens",
+        amountOut: quote.amountOut,
+        amountInMax: maxAmountIn2,
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds
+      }
+    });
+    return {
+      id: nextPlanId(context, "swap-v2"),
+      kind: "swap",
+      network: context.network,
+      owner,
+      summary: {
+        title: "Swap with SunSwap V2",
+        lines: [`Spend at most ${maxAmountIn2} sun`, `Receive ${quote.amountOut} token units`]
+      },
+      approvals,
+      transactions: [transaction2],
+      metadata: {
+        protocol: "sunswap-v2",
+        mode: quote.mode,
+        direction: quote.direction,
+        amountOut: quote.amountOut,
+        quotedAmountIn: quote.amountIn,
+        maxAmountIn: maxAmountIn2,
+        slippageBips,
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds
+      }
+    };
+  }
+  const tokenInputAmount = quote.mode === "exact-in" ? quote.amountIn : applySlippageMax(BigInt(quote.amountIn), slippageBips).toString();
+  const approval = await planApproval(context, {
+    asset: { type: "token", token: (0, import_sun_sdk_core23.assertTronAddress)(input.tokenIn, "tokenIn") },
+    owner,
+    spender: context.chain.contracts.sunswapV2Router,
+    amount: tokenInputAmount
+  }, {
+    mode: input.approval ?? "auto",
+    amount: "exact"
+  });
+  approvals.push(...approval.actions);
+  if (quote.mode === "exact-in") {
+    const minAmountOut = applySlippageMin(BigInt(quote.amountOut), slippageBips).toString();
+    const transaction2 = quote.direction === "token-to-trx" ? createDeferredV2SwapAction({
+      data: {
+        operation: "swap-exact-tokens-for-eth",
+        amountIn: quote.amountIn,
+        amountOutMin: minAmountOut,
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds
+      }
+    }) : createDeferredV2SwapAction({
+      data: {
+        operation: "swap-exact-tokens-for-tokens",
+        amountIn: quote.amountIn,
+        amountOutMin: minAmountOut,
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds
+      }
+    });
+    return {
+      id: nextPlanId(context, "swap-v2"),
+      kind: "swap",
+      network: context.network,
+      owner,
+      summary: {
+        title: "Swap with SunSwap V2",
+        lines: [
+          `Sell ${quote.amountIn} token units`,
+          `Receive at least ${minAmountOut} ${quote.direction === "token-to-trx" ? "sun" : "token units"}`
+        ]
+      },
+      approvals,
+      transactions: [transaction2],
+      metadata: {
+        protocol: "sunswap-v2",
+        mode: quote.mode,
+        direction: quote.direction,
+        amountIn: quote.amountIn,
+        quotedAmountOut: quote.amountOut,
+        minAmountOut,
+        slippageBips,
+        approvalMode: input.approval ?? "auto",
+        path: quote.path,
+        recipient,
+        transactionValidForSeconds,
+        owner,
+        spender: context.chain.contracts.sunswapV2Router
+      }
+    };
+  }
+  const maxAmountIn = tokenInputAmount;
+  const transaction = quote.direction === "token-to-trx" ? createDeferredV2SwapAction({
+    data: {
+      operation: "swap-tokens-for-exact-eth",
+      amountOut: quote.amountOut,
+      amountInMax: maxAmountIn,
+      path: quote.path,
+      recipient,
+      transactionValidForSeconds
+    }
+  }) : createDeferredV2SwapAction({
+    data: {
+      operation: "swap-tokens-for-exact-tokens",
+      amountOut: quote.amountOut,
+      amountInMax: maxAmountIn,
+      path: quote.path,
+      recipient,
+      transactionValidForSeconds
+    }
+  });
+  return {
+    id: nextPlanId(context, "swap-v2"),
+    kind: "swap",
+    network: context.network,
+    owner,
+    summary: {
+      title: "Swap with SunSwap V2",
+      lines: [
+        `Spend at most ${maxAmountIn} token units`,
+        `Receive ${quote.amountOut} ${quote.direction === "token-to-trx" ? "sun" : "token units"}`
+      ]
+    },
+    approvals,
+    transactions: [transaction],
+    metadata: {
+      protocol: "sunswap-v2",
+      mode: quote.mode,
+      direction: quote.direction,
+      amountOut: quote.amountOut,
+      quotedAmountIn: quote.amountIn,
+      maxAmountIn,
+      slippageBips,
+      approvalMode: input.approval ?? "auto",
+      path: quote.path,
+      recipient,
+      transactionValidForSeconds,
+      owner,
+      spender: context.chain.contracts.sunswapV2Router
+    }
+  };
+}
+var V2SwapClient = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  quote(_input) {
+    return quoteV2Swap(this.context, _input);
+  }
+  plan(input) {
+    return planV2Swap(this.context, input);
+  }
+  executeAction(action) {
+    return executePlanAction(action, createV2SwapExecutor(this.context));
+  }
+  submit(plan) {
+    assertSwapPlan(plan, ["sunswap-v2"], "SunSwap V2");
+    return executePlanTransactions(plan, createV2SwapExecutor(this.context));
+  }
+  async execute(input) {
+    const plan = isTransactionPlan(input) ? input : await planV2Swap(this.context, input);
+    assertSwapPlan(plan, ["sunswap-v2"], "SunSwap V2");
+    return executeTransactionPlan(plan, createV2SwapExecutor(this.context));
+  }
+};
+function createV2SwapClient(context) {
+  return new V2SwapClient(context);
+}
+function createV2Client(options) {
+  return createV2SwapClient(createProtocolsContext(options));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PSM_PROTOCOL_ID,
+  PsmSwapClient,
+  SwapRouterClient,
+  UNIVERSAL_ROUTER_PROTOCOL_ID,
+  V2SwapClient,
+  WTRX_PROTOCOL_ID,
+  createPsmClient,
+  createPsmSwapClient,
+  createRouterSwapExecutor,
+  createSwapRouterClient,
+  createV2Client,
+  createV2SwapClient,
+  createV2SwapExecutor,
+  detectWtrxSwap,
+  isNativeTrxToken,
+  isWrappedTrxToken,
+  materializeUniversalRouterAction,
+  normalizeRouterToken,
+  normalizeV2TrxPairPath,
+  planPsmSwap,
+  planRouterSwap,
+  quotePsmSwap,
+  quoteRouterSwap,
+  quoteSwap,
+  readPsm
+});
+//# sourceMappingURL=index.cjs.map