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

package/dist/chunk-ECCGOXNA.js

@@ -0,0 +1,1317 @@
+import {
+  planRouterPermit2Authorization
+} from "./chunk-OM4OW4KB.js";
+import {
+  assertUsdtTransfer
+} from "./chunk-5XDX5563.js";
+import {
+  normalizeTronAddress,
+  planApproval,
+  readRequiredContract
+} from "./chunk-C2YCVBPI.js";
+import {
+  createDeferredV2SwapAction,
+  createV2SwapExecutor
+} from "./chunk-TSHXXRH2.js";
+import {
+  applySlippageMax,
+  applySlippageMin,
+  attachApprovalIntent,
+  createContextExecutor,
+  createProtocolsContext,
+  executePlanAction,
+  executePlanTransactions,
+  executeTransactionPlan,
+  isTransactionPlan,
+  nextPlanId,
+  normalizeBaseUnitAmount,
+  normalizeFeeLimit,
+  normalizeRecipient,
+  normalizeTransactionValidForSeconds,
+  requireRuntime,
+  requireWalletSnapshot,
+  resolveProtocolContract,
+  resolveTransactionDeadline,
+  slippageToBips
+} from "./chunk-VFVKMC4H.js";
+
+// src/swap/intents.ts
+import {
+  SDKError
+} from "@sun-protocol/sun-sdk-core";
+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 SDKError("SDK_API_ERROR", "Selected Router route is missing token symbols");
+  }
+  return {
+    from: symbols[0],
+    to: symbols[symbols.length - 1]
+  };
+}
+
+// src/swap/psm.ts
+import {
+  buildPsmBuyGemAction,
+  buildPsmInfoRead,
+  buildPsmSellGemAction,
+  createPsmSnapshot,
+  normalizePsmInfoResult,
+  quotePsm
+} from "@sun-protocol/sun-sdk-psm";
+import {
+  SDKError as SDKError3,
+  assertTronAddress,
+  formatUnits
+} from "@sun-protocol/sun-sdk-core";
+
+// 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/swap/workflow.ts
+import { SDKError as SDKError2 } from "@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 SDKError2("SDK_INVALID_ARGUMENT", `Expected a ${clientName} swap plan`, {
+      planId: plan.id,
+      kind: plan.kind,
+      protocol,
+      transactionCount: plan.transactions.length
+    });
+  }
+}
+
+// src/swap/psm.ts
+function normalizePsmApprovalMode(value) {
+  if (value === void 0) return "auto";
+  if (value === "auto" || value === "approve" || value === "none") return value;
+  throw new SDKError3("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 SDKError3(
+    "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 SDKError3("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 SDKError3("SDK_INVALID_ARGUMENT", "unsupported PSM quote mode", { mode });
+  }
+  const tokenIn = assertTronAddress(input.tokenIn, "tokenIn");
+  const tokenOut = 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 SDKError3("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,
+    buildPsmInfoRead({
+      network: context.network,
+      psm: contracts.psm,
+      infoReader: contracts.psmInfoReader
+    }),
+    "PSM info read"
+  );
+  return createPsmSnapshot(normalizePsmInfoResult(result));
+}
+async function quotePsmSwap(context, input) {
+  const normalized = normalizeQuoteInput(context, input);
+  const snapshot = await readPsm(context, input);
+  return {
+    ...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 ? 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" ? buildPsmSellGemAction(actionOptions) : buildPsmBuyGemAction(actionOptions);
+  const transaction = {
+    ...transactionAction,
+    intent: {
+      kind: "swap",
+      scope: intentScope,
+      from: { value: formatUnits(BigInt(quote.amountIn), inputDecimals), symbol: inputSymbol },
+      to: { value: 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/router-execute.ts
+import {
+  SDKError as SDKError5
+} from "@sun-protocol/sun-sdk-core";
+
+// src/internal/router-action.ts
+import {
+  createDeferredContractCallAction
+} from "@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 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
+import {
+  SDKError as SDKError4,
+  createContractCallAction
+} from "@sun-protocol/sun-sdk-core";
+import {
+  Address,
+  TradePlanner,
+  parseRouteAPIResponse,
+  PoolType,
+  PoolVersion
+} from "@sun-protocol/universal-router-sdk";
+import { computeV3PoolAddress } from "@sun-protocol/sun-sdk-sunswap-v3";
+function requireString(route, key) {
+  const value = route[key];
+  if (typeof value !== "string") {
+    throw new SDKError4("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 SDKError4("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 SDKError4("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 SDKError4("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 SDKError4("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(PoolVersion).includes(version))) {
+    throw new SDKError4("SDK_INVALID_ARGUMENT", "Router route has inconsistent hop data");
+  }
+  routeData.tokens = routeData.tokens.map((token) => normalizeTronAddress(token));
+  const swapTradeRoute = parseRouteAPIResponse(routeData, input.network === "nile", {
+    slippageBips: input.slippageBips
+  });
+  if (input.recipient) {
+    swapTradeRoute.recipient = new Address(input.recipient);
+  }
+  const tradePlanner = new 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 !== PoolType.V3 || routeData.tokens[index + 1] !== usdtAddress) return;
+    const address = 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 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/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 SDKError5("SDK_RUNTIME_ERROR", `Unsupported deferred action kind: ${action.materialization.kind}`);
+  }
+  const data = action.materialization.data;
+  if (data.network !== context.network) {
+    throw new SDKError5("SDK_USDT_TRANSFER_UNKNOWN", "Network changed; rebuild the swap plan", { reason: "CHECK_FAILED" });
+  }
+  if (data.signatureActionId && !permitSignature) {
+    throw new SDKError5("SDK_INVALID_ARGUMENT", "Router swap requires the planned Permit2 signature", {
+      actionId: action.id,
+      signatureActionId: data.signatureActionId
+    });
+  }
+  if (data.signatureActionId && !data.permitSingle) {
+    throw new SDKError5("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 SDKError5("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/tokens.ts
+import { SDKError as SDKError6, assertTronAddress as assertTronAddress2 } from "@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 : assertTronAddress2(token, "token");
+}
+function normalizeV2TrxPairPath(context, input) {
+  const tokenInIsTrx = isNativeTrxToken(context, input.tokenIn);
+  const tokenOutIsTrx = isNativeTrxToken(context, input.tokenOut);
+  if (tokenInIsTrx === tokenOutIsTrx) {
+    throw new SDKError6("SDK_INVALID_ARGUMENT", "V2 swap currently supports exactly one TRX side", {
+      tokenIn: input.tokenIn,
+      tokenOut: input.tokenOut
+    });
+  }
+  const token = assertTronAddress2(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 assertTronAddress2(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 SDKError6("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 SDKError6("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 SDKError6("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 SDKError6("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/plan.ts
+import {
+  SDKError as SDKError7,
+  assertTronAddress as assertTronAddress3,
+  createContractCallAction as createContractCallAction2,
+  formatUnits as formatUnits2
+} from "@sun-protocol/sun-sdk-core";
+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 SDKError7("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: formatUnits2(BigInt(quote.amountIn), context.chain.nativeCurrency.decimals)
+  };
+  const transaction = quote.action === "wrap" ? createContractCallAction2({
+    id: `${nextPlanId(context, "swap-wtrx")}-wrap`,
+    target: context.chain.contracts.wtrx,
+    functionSelector: "deposit()",
+    parameters: [],
+    callValue: BigInt(quote.amountIn),
+    feeLimit: resolvedFeeLimit,
+    intent
+  }) : createContractCallAction2({
+    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 SDKError7("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 SDKError7("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 SDKError7("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: assertTronAddress3(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
+import { SDKError as SDKError8 } from "@sun-protocol/sun-sdk-core";
+function requireRoutes(response) {
+  if (response.code !== 0) {
+    throw new SDKError8("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 SDKError8("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 SDKError8("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 SDKError8("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 SDKError8("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 SDKError8("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 SDKError8("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 SDKError8("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 SDKError8("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/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/swap/v2.ts
+import {
+  buildV2RouterAllowedTradingPairRead,
+  buildV2RouterAmountsInRead,
+  buildV2RouterAmountsOutRead,
+  normalizeV2AmountsResult
+} from "@sun-protocol/sun-sdk-sunswap-v2";
+import {
+  SDKError as SDKError9,
+  assertTronAddress as assertTronAddress4
+} from "@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 SDKError9("SDK_INVALID_ARGUMENT", "exact-in V2 swap does not accept amountOut");
+    }
+    return mode;
+  }
+  normalizeBaseUnitAmount(input.amountOut ?? "", "amountOut");
+  if (input.amountIn !== void 0) {
+    throw new SDKError9("SDK_INVALID_ARGUMENT", "exact-out V2 swap does not accept amountIn");
+  }
+  return mode;
+}
+function requireAmount(amounts, index, operation) {
+  const amount = amounts[index];
+  if (amount === void 0) {
+    throw new SDKError9("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 SDKError9("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 = assertTronAddress4(path[index] ?? "", `path[${index}]`);
+    const tokenB = assertTronAddress4(path[index + 1] ?? "", `path[${index + 1}]`);
+    const allowed = normalizeAllowedTradingPairResult(await runtime.readContract(buildV2RouterAllowedTradingPairRead({
+      network: context.network,
+      tokenA,
+      tokenB
+    })));
+    if (!allowed) {
+      throw new SDKError9("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 = normalizeV2AmountsResult(await runtime.readContract(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: requireAmount(amounts2, amounts2.length - 1, "v2-exact-in-quote"),
+      path: pathInfo.path
+    };
+  }
+  const amountOut = normalizeBaseUnitAmount(input.amountOut ?? "", "amountOut");
+  const amounts = normalizeV2AmountsResult(await runtime.readContract(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: requireAmount(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: assertTronAddress4(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));
+}
+
+export {
+  UNIVERSAL_ROUTER_PROTOCOL_ID,
+  PSM_PROTOCOL_ID,
+  WTRX_PROTOCOL_ID,
+  readPsm,
+  quotePsmSwap,
+  planPsmSwap,
+  PsmSwapClient,
+  createPsmSwapClient,
+  createPsmClient,
+  materializeUniversalRouterAction,
+  createRouterSwapExecutor,
+  isNativeTrxToken,
+  normalizeRouterToken,
+  normalizeV2TrxPairPath,
+  isWrappedTrxToken,
+  detectWtrxSwap,
+  planRouterSwap,
+  quoteRouterSwap,
+  quoteSwap,
+  SwapRouterClient,
+  createSwapRouterClient,
+  V2SwapClient,
+  createV2SwapClient,
+  createV2Client
+};
+//# sourceMappingURL=chunk-ECCGOXNA.js.map