@sun-protocol/sun-sdk-sunswap-v2 0.1.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,1194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BASIS_POINTS: () => BASIS_POINTS,
+  FACTORY_ADDRESS: () => FACTORY_ADDRESS,
+  FACTORY_ADDRESS_MAP: () => FACTORY_ADDRESS_MAP,
+  FIVE: () => FIVE,
+  INIT_CODE_HASH: () => INIT_CODE_HASH,
+  INIT_CODE_HASH_MAP: () => INIT_CODE_HASH_MAP,
+  InsufficientInputAmountError: () => InsufficientInputAmountError,
+  InsufficientReservesError: () => InsufficientReservesError,
+  MINIMUM_LIQUIDITY: () => MINIMUM_LIQUIDITY,
+  ONE: () => ONE,
+  ONE_HUNDRED_PERCENT: () => ONE_HUNDRED_PERCENT,
+  Pair: () => Pair,
+  Route: () => Route,
+  Router: () => Router,
+  Trade: () => Trade,
+  V2_FACTORY_READ_SELECTORS: () => V2_FACTORY_READ_SELECTORS,
+  V2_INIT_CODE_HASH: () => V2_INIT_CODE_HASH,
+  V2_PAIR_READ_SELECTORS: () => V2_PAIR_READ_SELECTORS,
+  V2_ROUTER_READ_SELECTORS: () => V2_ROUTER_READ_SELECTORS,
+  V2_ROUTER_SELECTORS: () => V2_ROUTER_SELECTORS,
+  ZERO: () => ZERO,
+  ZERO_PERCENT: () => ZERO_PERCENT,
+  _1000: () => _1000,
+  _997: () => _997,
+  applyV2SlippageMin: () => applyV2SlippageMin,
+  buildV2AddLiquidityAction: () => buildV2AddLiquidityAction,
+  buildV2AddLiquidityEthAction: () => buildV2AddLiquidityEthAction,
+  buildV2FactoryFeeToRead: () => buildV2FactoryFeeToRead,
+  buildV2FactoryPairRead: () => buildV2FactoryPairRead,
+  buildV2LpApproveAction: () => buildV2LpApproveAction,
+  buildV2PairAllowanceRead: () => buildV2PairAllowanceRead,
+  buildV2PairBalanceRead: () => buildV2PairBalanceRead,
+  buildV2PairKLastRead: () => buildV2PairKLastRead,
+  buildV2PairReservesRead: () => buildV2PairReservesRead,
+  buildV2PairTotalSupplyRead: () => buildV2PairTotalSupplyRead,
+  buildV2RemoveLiquidityAction: () => buildV2RemoveLiquidityAction,
+  buildV2RemoveLiquidityEthAction: () => buildV2RemoveLiquidityEthAction,
+  buildV2RouterAllowedTradingPairRead: () => buildV2RouterAllowedTradingPairRead,
+  buildV2RouterAmountsInRead: () => buildV2RouterAmountsInRead,
+  buildV2RouterAmountsOutRead: () => buildV2RouterAmountsOutRead,
+  buildV2SwapEthForExactTokensAction: () => buildV2SwapEthForExactTokensAction,
+  buildV2SwapExactEthForTokensAction: () => buildV2SwapExactEthForTokensAction,
+  buildV2SwapExactTokensForEthAction: () => buildV2SwapExactTokensForEthAction,
+  buildV2SwapExactTokensForTokensAction: () => buildV2SwapExactTokensForTokensAction,
+  buildV2SwapTokensForExactEthAction: () => buildV2SwapTokensForExactEthAction,
+  buildV2SwapTokensForExactTokensAction: () => buildV2SwapTokensForExactTokensAction,
+  computePairAddress: () => computePairAddress,
+  computeV2PairAddress: () => computeV2PairAddress,
+  createV2PairKey: () => createV2PairKey,
+  evmHexToTronAddress: () => evmHexToTronAddress,
+  getV2AddLiquidityMinimums: () => getV2AddLiquidityMinimums,
+  getV2RemoveLiquidityMinimums: () => getV2RemoveLiquidityMinimums,
+  inputOutputComparator: () => inputOutputComparator,
+  normalizeV2AmountsResult: () => normalizeV2AmountsResult,
+  normalizeV2ReserveResult: () => normalizeV2ReserveResult,
+  quoteV2LiquidityAmount: () => quoteV2LiquidityAmount,
+  sortV2Tokens: () => sortV2Tokens,
+  tradeComparator: () => tradeComparator,
+  tronAddressToEvmHex: () => tronAddressToEvmHex,
+  tronCreate2Address: () => tronCreate2Address
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/actions.ts
+var import_sun_sdk_chains2 = require("@sun-protocol/sun-sdk-chains");
+var import_sun_sdk_core2 = require("@sun-protocol/sun-sdk-core");
+
+// src/utils.ts
+var import_sun_sdk_chains = require("@sun-protocol/sun-sdk-chains");
+var import_keccak256 = require("@ethersproject/keccak256");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_sun_sdk_core = require("@sun-protocol/sun-sdk-core");
+var V2_INIT_CODE_HASH = {
+  mainnet: "0x6d3f89421f83e4b62e628de8fc7ff2b014a79bf8fd8e8b0ea46e4a1d9409b67d",
+  nile: "0x9dd9bfc2f6c1103a6c01d9c6a4044e4b8a9361f92df2728cdc3729922d56748e"
+};
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE58_ZERO = "1";
+var HEX_20_BYTES_PATTERN = /^0x[a-fA-F0-9]{40}$/;
+var HEX_20_BYTES_NO_PREFIX_PATTERN = /^[a-fA-F0-9]{40}$/;
+var HEX_32_BYTES_PATTERN = /^(?:0x)?[a-fA-F0-9]{64}$/;
+var TRON_ADDRESS_PAYLOAD_BYTES = 25;
+var TRON_ADDRESS_BYTES = 21;
+var TRON_PREFIX_HEX = "41";
+function toBigInt(value) {
+  return BigInt(value.toString());
+}
+function validatePositive(value, label) {
+  (0, import_sun_sdk_core.sdkInvariant)(value > 0n, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be positive`, {
+    [label]: value.toString()
+  });
+}
+function sortV2Tokens(tokenA, tokenB) {
+  return tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
+}
+function decodeBase58(value) {
+  let decoded = 0n;
+  for (const char of value) {
+    const index = BASE58_ALPHABET.indexOf(char);
+    (0, import_sun_sdk_core.sdkInvariant)(index >= 0, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Invalid base58 character", { value, char });
+    decoded = decoded * 58n + BigInt(index);
+  }
+  const bytes = [];
+  while (decoded > 0n) {
+    bytes.unshift(Number(decoded & 0xffn));
+    decoded >>= 8n;
+  }
+  for (const char of value) {
+    if (char !== "1") break;
+    bytes.unshift(0);
+  }
+  return Uint8Array.from(bytes);
+}
+function encodeBase58(bytes) {
+  let value = 0n;
+  for (const byte of bytes) {
+    value = (value << 8n) + BigInt(byte);
+  }
+  let encoded = "";
+  while (value > 0n) {
+    const mod = Number(value % 58n);
+    const char = BASE58_ALPHABET[mod];
+    (0, import_sun_sdk_core.sdkInvariant)(char !== void 0, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Invalid base58 remainder", { mod });
+    encoded = char + encoded;
+    value /= 58n;
+  }
+  for (const byte of bytes) {
+    if (byte !== 0) break;
+    encoded = `${BASE58_ZERO}${encoded}`;
+  }
+  return encoded || BASE58_ZERO;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex, label) {
+  const normalized = hex.startsWith("0x") ? hex.slice(2) : hex;
+  (0, import_sun_sdk_core.sdkInvariant)(/^[a-fA-F0-9]*$/.test(normalized) && normalized.length % 2 === 0, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be even-length hex`, {
+    label,
+    value: hex
+  });
+  const bytes = new Uint8Array(normalized.length / 2);
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = Number.parseInt(normalized.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function checksum(payload) {
+  return (0, import_sha256.sha256)((0, import_sha256.sha256)(payload)).slice(0, 4);
+}
+function tronPayloadToBase58(payload) {
+  const bytes = new Uint8Array(TRON_ADDRESS_PAYLOAD_BYTES);
+  bytes.set(payload, 0);
+  bytes.set(checksum(payload), TRON_ADDRESS_BYTES);
+  return encodeBase58(bytes);
+}
+function tronAddressToEvmHex(address, label = "address") {
+  if (HEX_20_BYTES_PATTERN.test(address)) return address.slice(2).toLowerCase();
+  if (HEX_20_BYTES_NO_PREFIX_PATTERN.test(address)) return address.toLowerCase();
+  const decoded = decodeBase58(address);
+  (0, import_sun_sdk_core.sdkInvariant)(
+    decoded.length === TRON_ADDRESS_PAYLOAD_BYTES,
+    import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    `${label} must be a TRON base58 address or 20-byte EVM hex address`,
+    { label, value: address }
+  );
+  const body = decoded.slice(0, TRON_ADDRESS_BYTES);
+  const expectedChecksum = checksum(body);
+  const actualChecksum = decoded.slice(TRON_ADDRESS_BYTES);
+  (0, import_sun_sdk_core.sdkInvariant)(
+    bytesToHex(expectedChecksum) === bytesToHex(actualChecksum),
+    import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    `${label} has invalid TRON base58 checksum`,
+    { label, value: address }
+  );
+  (0, import_sun_sdk_core.sdkInvariant)(body[0] === 65, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must use TRON 0x41 prefix`, {
+    label,
+    value: address
+  });
+  return bytesToHex(body.slice(1));
+}
+function evmHexToTronAddress(address, label = "address") {
+  (0, import_sun_sdk_core.sdkInvariant)(HEX_20_BYTES_PATTERN.test(address), import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, `${label} must be a 20-byte EVM hex address`, {
+    label,
+    value: address
+  });
+  return tronPayloadToBase58(hexToBytes(`${TRON_PREFIX_HEX}${address.slice(2)}`, label));
+}
+function tronCreate2Address(params) {
+  const factory = tronAddressToEvmHex(params.factoryAddress, "factory");
+  const salt = normalizeV2InitCodeHash(params.salt);
+  const initCodeHash = normalizeV2InitCodeHash(params.initCodeHash);
+  const hash = (0, import_keccak256.keccak256)(hexToBytes(`${TRON_PREFIX_HEX}${factory}${salt}${initCodeHash}`, "CREATE2 input")).slice(2);
+  return tronPayloadToBase58(hexToBytes(`${TRON_PREFIX_HEX}${hash.slice(-40)}`, "contract address"));
+}
+function normalizeV2InitCodeHash(value) {
+  (0, import_sun_sdk_core.sdkInvariant)(HEX_32_BYTES_PATTERN.test(value), import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "V2 initCodeHash must be bytes32 hex", {
+    value
+  });
+  return value.startsWith("0x") ? value.slice(2).toLowerCase() : value.toLowerCase();
+}
+function normalizeV2TokenAddress(address, wrappedNative, label) {
+  const normalized = address === "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb" ? wrappedNative : address;
+  return tronAddressToEvmHex(normalized, label);
+}
+function computeV2PairAddress(params) {
+  const wrappedNative = params.wrappedNative ?? (0, import_sun_sdk_chains.getWrappedNativeAddress)(params.network);
+  const tokenA = normalizeV2TokenAddress(params.tokenA, wrappedNative, "tokenA");
+  const tokenB = normalizeV2TokenAddress(params.tokenB, wrappedNative, "tokenB");
+  (0, import_sun_sdk_core.sdkInvariant)(tokenA !== tokenB, import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "V2 pair tokens must be different", {
+    tokenA: params.tokenA,
+    tokenB: params.tokenB
+  });
+  const [token0, token1] = tokenA < tokenB ? [tokenA, tokenB] : [tokenB, tokenA];
+  const factory = tronAddressToEvmHex(params.factory ?? (0, import_sun_sdk_chains.getContractAddress)(params.network, "sunswapV2Factory"), "factory");
+  const tokenHash = (0, import_keccak256.keccak256)(hexToBytes(`${token0}${token1}`, "token salt")).slice(2);
+  const initCodeHash = normalizeV2InitCodeHash(params.initCodeHash ?? V2_INIT_CODE_HASH[params.network]);
+  return tronCreate2Address({ factoryAddress: factory, salt: tokenHash, initCodeHash });
+}
+function createV2PairKey(input) {
+  const [token0, token1] = sortV2Tokens(input.tokenA, input.tokenB);
+  return { network: input.network, token0, token1 };
+}
+function quoteV2LiquidityAmount(amountA, reserveA, reserveB) {
+  const amount = toBigInt(amountA);
+  const reserveIn = toBigInt(reserveA);
+  const reserveOut = toBigInt(reserveB);
+  validatePositive(amount, "amountA");
+  validatePositive(reserveIn, "reserveA");
+  validatePositive(reserveOut, "reserveB");
+  return (amount * reserveOut / reserveIn).toString();
+}
+function applyV2SlippageMin(amount, slippageTolerance) {
+  (0, import_sun_sdk_core.sdkInvariant)(
+    !slippageTolerance.lessThan(0),
+    import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "Slippage tolerance cannot be negative",
+    { slippageTolerance: slippageTolerance.toSignificant() }
+  );
+  (0, import_sun_sdk_core.sdkInvariant)(
+    !slippageTolerance.greaterThan(1),
+    import_sun_sdk_core.SDK_ERROR_CODES.SDK_INVALID_ARGUMENT,
+    "Slippage tolerance cannot exceed 100%",
+    { slippageTolerance: slippageTolerance.toSignificant() }
+  );
+  return new import_sun_sdk_core.Percent(1).subtract(slippageTolerance).multiply(amount.toString()).quotient.toString();
+}
+function getV2AddLiquidityMinimums(amounts, slippageTolerance) {
+  return {
+    amountAMin: applyV2SlippageMin(amounts.amountA, slippageTolerance),
+    amountBMin: applyV2SlippageMin(amounts.amountB, slippageTolerance)
+  };
+}
+function getV2RemoveLiquidityMinimums(amounts, slippageTolerance) {
+  return getV2AddLiquidityMinimums(amounts, slippageTolerance);
+}
+
+// src/actions.ts
+var V2_ROUTER_SELECTORS = {
+  addLiquidity: "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)",
+  addLiquidityETH: "addLiquidityETH(address,uint256,uint256,uint256,address,uint256)",
+  removeLiquidity: "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)",
+  removeLiquidityETH: "removeLiquidityETH(address,uint256,uint256,uint256,address,uint256)",
+  swapExactETHForTokens: "swapExactETHForTokens(uint256,address[],address,uint256)",
+  swapETHForExactTokens: "swapETHForExactTokens(uint256,address[],address,uint256)",
+  swapExactTokensForETH: "swapExactTokensForETH(uint256,uint256,address[],address,uint256)",
+  swapExactTokensForTokens: "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)",
+  swapTokensForExactETH: "swapTokensForExactETH(uint256,uint256,address[],address,uint256)",
+  swapTokensForExactTokens: "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)"
+};
+function routerTarget(params) {
+  return params.router ?? (0, import_sun_sdk_chains2.getContractAddress)(params.network, "sunswapV2Router");
+}
+function valueOf(value) {
+  return value.toString();
+}
+function actionId(params, suffix) {
+  return params.id ?? `sunswap-v2-${suffix}-${params.network}`;
+}
+function buildV2AddLiquidityAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "add-liquidity"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.addLiquidity,
+    parameters: [
+      { type: "address", value: evmHexToTronAddress(params.tokenA.address, "tokenA") },
+      { type: "address", value: evmHexToTronAddress(params.tokenB.address, "tokenB") },
+      { type: "uint256", value: valueOf(params.amountADesired) },
+      { type: "uint256", value: valueOf(params.amountBDesired) },
+      { type: "uint256", value: valueOf(params.amountAMin) },
+      { type: "uint256", value: valueOf(params.amountBMin) },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2RemoveLiquidityAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "remove-liquidity"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.removeLiquidity,
+    parameters: [
+      { type: "address", value: evmHexToTronAddress(params.tokenA.address, "tokenA") },
+      { type: "address", value: evmHexToTronAddress(params.tokenB.address, "tokenB") },
+      { type: "uint256", value: valueOf(params.liquidity) },
+      { type: "uint256", value: valueOf(params.amountAMin) },
+      { type: "uint256", value: valueOf(params.amountBMin) },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2AddLiquidityEthAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "add-liquidity-eth"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.addLiquidityETH,
+    parameters: [
+      { type: "address", value: evmHexToTronAddress(params.token.address, "token") },
+      { type: "uint256", value: valueOf(params.amountTokenDesired) },
+      { type: "uint256", value: valueOf(params.amountTokenMin) },
+      { type: "uint256", value: valueOf(params.amountEthMin) },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    callValue: BigInt(valueOf(params.amountEthDesired)),
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2RemoveLiquidityEthAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "remove-liquidity-eth"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.removeLiquidityETH,
+    parameters: [
+      { type: "address", value: evmHexToTronAddress(params.token.address, "token") },
+      { type: "uint256", value: valueOf(params.liquidity) },
+      { type: "uint256", value: valueOf(params.amountTokenMin) },
+      { type: "uint256", value: valueOf(params.amountEthMin) },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2SwapExactEthForTokensAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "swap-exact-eth-for-tokens"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.swapExactETHForTokens,
+    parameters: [
+      { type: "uint256", value: valueOf(params.amountOutMin) },
+      { type: "address[]", value: params.path },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    callValue: BigInt(valueOf(params.amountIn)),
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2SwapEthForExactTokensAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "swap-eth-for-exact-tokens"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.swapETHForExactTokens,
+    parameters: [
+      { type: "uint256", value: valueOf(params.amountOut) },
+      { type: "address[]", value: params.path },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    callValue: BigInt(valueOf(params.amountInMax)),
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2SwapExactTokensForEthAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "swap-exact-tokens-for-eth"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.swapExactTokensForETH,
+    parameters: [
+      { type: "uint256", value: valueOf(params.amountIn) },
+      { type: "uint256", value: valueOf(params.amountOutMin) },
+      { type: "address[]", value: params.path },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2SwapExactTokensForTokensAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "swap-exact-tokens-for-tokens"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.swapExactTokensForTokens,
+    parameters: [
+      { type: "uint256", value: valueOf(params.amountIn) },
+      { type: "uint256", value: valueOf(params.amountOutMin) },
+      { type: "address[]", value: params.path },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2SwapTokensForExactEthAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "swap-tokens-for-exact-eth"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.swapTokensForExactETH,
+    parameters: [
+      { type: "uint256", value: valueOf(params.amountOut) },
+      { type: "uint256", value: valueOf(params.amountInMax) },
+      { type: "address[]", value: params.path },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2SwapTokensForExactTokensAction(params) {
+  return (0, import_sun_sdk_core2.createContractCallAction)({
+    id: actionId(params, "swap-tokens-for-exact-tokens"),
+    target: routerTarget(params),
+    functionSelector: V2_ROUTER_SELECTORS.swapTokensForExactTokens,
+    parameters: [
+      { type: "uint256", value: valueOf(params.amountOut) },
+      { type: "uint256", value: valueOf(params.amountInMax) },
+      { type: "address[]", value: params.path },
+      { type: "address", value: params.recipient },
+      { type: "uint256", value: valueOf(params.deadline) }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV2LpApproveAction(params) {
+  return (0, import_sun_sdk_core2.createApproveAction)({
+    id: params.id ?? `sunswap-v2-lp-approve-${params.pair}`,
+    target: params.pair,
+    spender: params.spender,
+    amount: valueOf(params.amount),
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+
+// src/constants.ts
+var import_sun_sdk_core3 = require("@sun-protocol/sun-sdk-core");
+var import_jsbi = __toESM(require("jsbi"), 1);
+var FACTORY_ADDRESS = "0x689abaeeed3f0bb3585773192e23224cac25dd41";
+var FACTORY_ADDRESS_MAP = {
+  728126428: FACTORY_ADDRESS,
+  3448148188: "0x55f7d5d874a73f21c0851c62d374307985f440fc"
+};
+var INIT_CODE_HASH = "0x6d3f89421f83e4b62e628de8fc7ff2b014a79bf8fd8e8b0ea46e4a1d9409b67d";
+var INIT_CODE_HASH_MAP = {
+  728126428: INIT_CODE_HASH,
+  3448148188: "0x9dd9bfc2f6c1103a6c01d9c6a4044e4b8a9361f92df2728cdc3729922d56748e"
+};
+var MINIMUM_LIQUIDITY = import_jsbi.default.BigInt(1e3);
+var ZERO = import_jsbi.default.BigInt(0);
+var ONE = import_jsbi.default.BigInt(1);
+var FIVE = import_jsbi.default.BigInt(5);
+var _997 = import_jsbi.default.BigInt(997);
+var _1000 = import_jsbi.default.BigInt(1e3);
+var BASIS_POINTS = import_jsbi.default.BigInt(1e4);
+var ZERO_PERCENT = new import_sun_sdk_core3.Percent(ZERO);
+var ONE_HUNDRED_PERCENT = new import_sun_sdk_core3.Percent(ONE);
+
+// src/errors.ts
+var InsufficientReservesError = class extends Error {
+  isInsufficientReservesError = true;
+  constructor() {
+    super("Insufficient reserves");
+    this.name = this.constructor.name;
+  }
+};
+var InsufficientInputAmountError = class extends Error {
+  isInsufficientInputAmountError = true;
+  constructor() {
+    super("Insufficient input amount");
+    this.name = this.constructor.name;
+  }
+};
+
+// src/entities/pair.ts
+var import_bignumber = require("@ethersproject/bignumber");
+var import_solidity = require("@ethersproject/solidity");
+var import_sun_sdk_core4 = require("@sun-protocol/sun-sdk-core");
+var import_jsbi2 = __toESM(require("jsbi"), 1);
+var import_tiny_invariant = __toESM(require("tiny-invariant"), 1);
+var computePairAddress = ({
+  factoryAddress,
+  tokenA,
+  tokenB,
+  initCodeHashManualOverride
+}) => {
+  const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
+  const salt = (0, import_solidity.keccak256)(["bytes"], [(0, import_solidity.pack)(["address", "address"], [token0.address, token1.address])]);
+  const tronAddress = tronCreate2Address({
+    factoryAddress,
+    salt,
+    initCodeHash: initCodeHashManualOverride ?? INIT_CODE_HASH_MAP[tokenA.chainId] ?? INIT_CODE_HASH
+  });
+  return `0x${tronAddressToEvmHex(tronAddress)}`;
+};
+var Pair = class _Pair {
+  liquidityToken;
+  tokenAmounts;
+  static getAddress(tokenA, tokenB) {
+    const factoryAddress = FACTORY_ADDRESS_MAP[tokenA.chainId] ?? FACTORY_ADDRESS;
+    return computePairAddress({ factoryAddress, tokenA, tokenB });
+  }
+  constructor(currencyAmountA, tokenAmountB) {
+    const tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) ? [currencyAmountA, tokenAmountB] : [tokenAmountB, currencyAmountA];
+    this.liquidityToken = new import_sun_sdk_core4.Token(
+      tokenAmounts[0].currency.chainId,
+      _Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency),
+      18,
+      "UNI-V2",
+      "Uniswap V2"
+    );
+    this.tokenAmounts = tokenAmounts;
+  }
+  involvesToken(token) {
+    return token.equals(this.token0) || token.equals(this.token1);
+  }
+  get token0Price() {
+    const result = this.tokenAmounts[1].divide(this.tokenAmounts[0]);
+    return new import_sun_sdk_core4.Price(this.token0, this.token1, result.denominator, result.numerator);
+  }
+  get token1Price() {
+    const result = this.tokenAmounts[0].divide(this.tokenAmounts[1]);
+    return new import_sun_sdk_core4.Price(this.token1, this.token0, result.denominator, result.numerator);
+  }
+  priceOf(token) {
+    (0, import_tiny_invariant.default)(this.involvesToken(token), "TOKEN");
+    return token.equals(this.token0) ? this.token0Price : this.token1Price;
+  }
+  get chainId() {
+    return this.token0.chainId;
+  }
+  get token0() {
+    return this.tokenAmounts[0].currency;
+  }
+  get token1() {
+    return this.tokenAmounts[1].currency;
+  }
+  get reserve0() {
+    return this.tokenAmounts[0];
+  }
+  get reserve1() {
+    return this.tokenAmounts[1];
+  }
+  reserveOf(token) {
+    (0, import_tiny_invariant.default)(this.involvesToken(token), "TOKEN");
+    return token.equals(this.token0) ? this.reserve0 : this.reserve1;
+  }
+  getOutputAmount(inputAmount, calculateFotFees = true) {
+    (0, import_tiny_invariant.default)(this.involvesToken(inputAmount.currency), "TOKEN");
+    if (import_jsbi2.default.equal(this.reserve0.quotient, ZERO) || import_jsbi2.default.equal(this.reserve1.quotient, ZERO)) {
+      throw new InsufficientReservesError();
+    }
+    const inputReserve = this.reserveOf(inputAmount.currency);
+    const outputReserve = this.reserveOf(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
+    const percentAfterSellFees = calculateFotFees ? this.derivePercentAfterSellFees(inputAmount) : ZERO_PERCENT;
+    const inputAmountAfterTax = percentAfterSellFees.greaterThan(ZERO_PERCENT) ? import_sun_sdk_core4.CurrencyAmount.fromRawAmount(inputAmount.currency, percentAfterSellFees.multiply(inputAmount).quotient) : inputAmount;
+    const inputAmountWithFeeAndAfterTax = import_jsbi2.default.multiply(inputAmountAfterTax.quotient, _997);
+    const numerator = import_jsbi2.default.multiply(inputAmountWithFeeAndAfterTax, outputReserve.quotient);
+    const denominator = import_jsbi2.default.add(import_jsbi2.default.multiply(inputReserve.quotient, _1000), inputAmountWithFeeAndAfterTax);
+    const outputAmount = import_sun_sdk_core4.CurrencyAmount.fromRawAmount(
+      inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
+      import_jsbi2.default.divide(numerator, denominator)
+    );
+    if (import_jsbi2.default.equal(outputAmount.quotient, ZERO)) {
+      throw new InsufficientInputAmountError();
+    }
+    const percentAfterBuyFees = calculateFotFees ? this.derivePercentAfterBuyFees(outputAmount) : ZERO_PERCENT;
+    const outputAmountAfterTax = percentAfterBuyFees.greaterThan(ZERO_PERCENT) ? import_sun_sdk_core4.CurrencyAmount.fromRawAmount(outputAmount.currency, outputAmount.multiply(percentAfterBuyFees).quotient) : outputAmount;
+    if (import_jsbi2.default.equal(outputAmountAfterTax.quotient, ZERO)) {
+      throw new InsufficientInputAmountError();
+    }
+    return [outputAmountAfterTax, new _Pair(inputReserve.add(inputAmountAfterTax), outputReserve.subtract(outputAmountAfterTax))];
+  }
+  getInputAmount(outputAmount, calculateFotFees = true) {
+    (0, import_tiny_invariant.default)(this.involvesToken(outputAmount.currency), "TOKEN");
+    const percentAfterBuyFees = calculateFotFees ? this.derivePercentAfterBuyFees(outputAmount) : ZERO_PERCENT;
+    const outputAmountBeforeTax = percentAfterBuyFees.greaterThan(ZERO_PERCENT) ? import_sun_sdk_core4.CurrencyAmount.fromRawAmount(outputAmount.currency, import_jsbi2.default.add(outputAmount.divide(percentAfterBuyFees).quotient, ONE)) : outputAmount;
+    if (import_jsbi2.default.equal(this.reserve0.quotient, ZERO) || import_jsbi2.default.equal(this.reserve1.quotient, ZERO) || import_jsbi2.default.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient) || import_jsbi2.default.greaterThanOrEqual(outputAmountBeforeTax.quotient, this.reserveOf(outputAmount.currency).quotient)) {
+      throw new InsufficientReservesError();
+    }
+    const outputReserve = this.reserveOf(outputAmount.currency);
+    const inputReserve = this.reserveOf(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
+    const numerator = import_jsbi2.default.multiply(import_jsbi2.default.multiply(inputReserve.quotient, outputAmountBeforeTax.quotient), _1000);
+    const denominator = import_jsbi2.default.multiply(import_jsbi2.default.subtract(outputReserve.quotient, outputAmountBeforeTax.quotient), _997);
+    const inputAmount = import_sun_sdk_core4.CurrencyAmount.fromRawAmount(
+      outputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
+      import_jsbi2.default.add(import_jsbi2.default.divide(numerator, denominator), ONE)
+    );
+    const percentAfterSellFees = calculateFotFees ? this.derivePercentAfterSellFees(inputAmount) : ZERO_PERCENT;
+    const inputAmountBeforeTax = percentAfterSellFees.greaterThan(ZERO_PERCENT) ? import_sun_sdk_core4.CurrencyAmount.fromRawAmount(inputAmount.currency, import_jsbi2.default.add(inputAmount.divide(percentAfterSellFees).quotient, ONE)) : inputAmount;
+    return [inputAmountBeforeTax, new _Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
+  }
+  getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
+    (0, import_tiny_invariant.default)(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
+    const tokenAmounts = tokenAmountA.currency.sortsBefore(tokenAmountB.currency) ? [tokenAmountA, tokenAmountB] : [tokenAmountB, tokenAmountA];
+    (0, import_tiny_invariant.default)(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
+    let liquidity;
+    if (import_jsbi2.default.equal(totalSupply.quotient, ZERO)) {
+      liquidity = import_jsbi2.default.subtract((0, import_sun_sdk_core4.sqrt)(import_jsbi2.default.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)), MINIMUM_LIQUIDITY);
+    } else {
+      const amount0 = import_jsbi2.default.divide(import_jsbi2.default.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient);
+      const amount1 = import_jsbi2.default.divide(import_jsbi2.default.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient);
+      liquidity = import_jsbi2.default.lessThanOrEqual(amount0, amount1) ? amount0 : amount1;
+    }
+    if (!import_jsbi2.default.greaterThan(liquidity, ZERO)) {
+      throw new InsufficientInputAmountError();
+    }
+    return import_sun_sdk_core4.CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity);
+  }
+  getLiquidityValue(token, totalSupply, liquidity, feeOn = false, kLast) {
+    (0, import_tiny_invariant.default)(this.involvesToken(token), "TOKEN");
+    (0, import_tiny_invariant.default)(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
+    (0, import_tiny_invariant.default)(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
+    (0, import_tiny_invariant.default)(import_jsbi2.default.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
+    let totalSupplyAdjusted;
+    if (!feeOn) {
+      totalSupplyAdjusted = totalSupply;
+    } else {
+      (0, import_tiny_invariant.default)(!!kLast, "K_LAST");
+      const kLastParsed = import_jsbi2.default.BigInt(kLast);
+      if (!import_jsbi2.default.equal(kLastParsed, ZERO)) {
+        const rootK = (0, import_sun_sdk_core4.sqrt)(import_jsbi2.default.multiply(this.reserve0.quotient, this.reserve1.quotient));
+        const rootKLast = (0, import_sun_sdk_core4.sqrt)(kLastParsed);
+        if (import_jsbi2.default.greaterThan(rootK, rootKLast)) {
+          const numerator = import_jsbi2.default.multiply(totalSupply.quotient, import_jsbi2.default.subtract(rootK, rootKLast));
+          const denominator = import_jsbi2.default.add(import_jsbi2.default.multiply(rootK, FIVE), rootKLast);
+          const feeLiquidity = import_jsbi2.default.divide(numerator, denominator);
+          totalSupplyAdjusted = totalSupply.add(import_sun_sdk_core4.CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity));
+        } else {
+          totalSupplyAdjusted = totalSupply;
+        }
+      } else {
+        totalSupplyAdjusted = totalSupply;
+      }
+    }
+    return import_sun_sdk_core4.CurrencyAmount.fromRawAmount(
+      token,
+      import_jsbi2.default.divide(import_jsbi2.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)
+    );
+  }
+  derivePercentAfterSellFees(inputAmount) {
+    const sellFeeBips = this.token0.wrapped.equals(inputAmount.wrapped.currency) ? this.token0.wrapped.sellFeeBps : this.token1.wrapped.sellFeeBps;
+    if (sellFeeBips?.gt(import_bignumber.BigNumber.from(0))) {
+      return ONE_HUNDRED_PERCENT.subtract(new import_sun_sdk_core4.Percent(import_jsbi2.default.BigInt(sellFeeBips)).divide(BASIS_POINTS));
+    }
+    return ZERO_PERCENT;
+  }
+  derivePercentAfterBuyFees(outputAmount) {
+    const buyFeeBps = this.token0.wrapped.equals(outputAmount.wrapped.currency) ? this.token0.wrapped.buyFeeBps : this.token1.wrapped.buyFeeBps;
+    if (buyFeeBps?.gt(import_bignumber.BigNumber.from(0))) {
+      return ONE_HUNDRED_PERCENT.subtract(new import_sun_sdk_core4.Percent(import_jsbi2.default.BigInt(buyFeeBps)).divide(BASIS_POINTS));
+    }
+    return ZERO_PERCENT;
+  }
+};
+
+// src/entities/route.ts
+var import_sun_sdk_core5 = require("@sun-protocol/sun-sdk-core");
+var import_tiny_invariant2 = __toESM(require("tiny-invariant"), 1);
+var Route = class {
+  pairs;
+  path;
+  input;
+  output;
+  _midPrice = null;
+  constructor(pairs, input, output) {
+    (0, import_tiny_invariant2.default)(pairs.length > 0, "PAIRS");
+    const firstPair = pairs[0];
+    const chainId = firstPair.chainId;
+    (0, import_tiny_invariant2.default)(pairs.every((pair) => pair.chainId === chainId), "CHAIN_IDS");
+    const wrappedInput = input.wrapped;
+    (0, import_tiny_invariant2.default)(firstPair.involvesToken(wrappedInput), "INPUT");
+    (0, import_tiny_invariant2.default)(typeof output === "undefined" || pairs[pairs.length - 1].involvesToken(output.wrapped), "OUTPUT");
+    const path = [wrappedInput];
+    for (const [i, pair] of pairs.entries()) {
+      const currentInput = path[i];
+      (0, import_tiny_invariant2.default)(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
+      const currentOutput = currentInput.equals(pair.token0) ? pair.token1 : pair.token0;
+      path.push(currentOutput);
+    }
+    this.pairs = pairs;
+    this.path = path;
+    this.input = input;
+    this.output = output ?? path[path.length - 1];
+  }
+  get midPrice() {
+    if (this._midPrice !== null) return this._midPrice;
+    const prices = [];
+    for (const [i, pair] of this.pairs.entries()) {
+      prices.push(
+        this.path[i].equals(pair.token0) ? new import_sun_sdk_core5.Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new import_sun_sdk_core5.Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient)
+      );
+    }
+    const reduced = prices.slice(1).reduce((accumulator, currentValue) => accumulator.multiply(currentValue), prices[0]);
+    return this._midPrice = new import_sun_sdk_core5.Price(this.input, this.output, reduced.denominator, reduced.numerator);
+  }
+  get chainId() {
+    return this.pairs[0].chainId;
+  }
+};
+
+// src/entities/trade.ts
+var import_sun_sdk_core6 = require("@sun-protocol/sun-sdk-core");
+var import_jsbi3 = __toESM(require("jsbi"), 1);
+var import_tiny_invariant3 = __toESM(require("tiny-invariant"), 1);
+function inputOutputComparator(a, b) {
+  (0, import_tiny_invariant3.default)(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
+  (0, import_tiny_invariant3.default)(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
+  if (a.outputAmount.equalTo(b.outputAmount)) {
+    if (a.inputAmount.equalTo(b.inputAmount)) return 0;
+    return a.inputAmount.lessThan(b.inputAmount) ? -1 : 1;
+  }
+  return a.outputAmount.lessThan(b.outputAmount) ? 1 : -1;
+}
+function tradeComparator(a, b) {
+  const ioComp = inputOutputComparator(a, b);
+  if (ioComp !== 0) return ioComp;
+  if (a.priceImpact.lessThan(b.priceImpact)) return -1;
+  if (a.priceImpact.greaterThan(b.priceImpact)) return 1;
+  return a.route.path.length - b.route.path.length;
+}
+var Trade = class _Trade {
+  route;
+  tradeType;
+  inputAmount;
+  outputAmount;
+  executionPrice;
+  priceImpact;
+  static exactIn(route, amountIn) {
+    return new _Trade(route, amountIn, import_sun_sdk_core6.TradeType.EXACT_INPUT);
+  }
+  static exactOut(route, amountOut) {
+    return new _Trade(route, amountOut, import_sun_sdk_core6.TradeType.EXACT_OUTPUT);
+  }
+  constructor(route, amount, tradeType) {
+    this.route = route;
+    this.tradeType = tradeType;
+    const tokenAmounts = new Array(route.path.length);
+    if (tradeType === import_sun_sdk_core6.TradeType.EXACT_INPUT) {
+      (0, import_tiny_invariant3.default)(amount.currency.equals(route.input), "INPUT");
+      tokenAmounts[0] = amount.wrapped;
+      for (let i = 0; i < route.path.length - 1; i += 1) {
+        const pair = route.pairs[i];
+        const [outputAmount] = pair.getOutputAmount(tokenAmounts[i].wrapped);
+        tokenAmounts[i + 1] = outputAmount;
+      }
+      this.inputAmount = import_sun_sdk_core6.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+      this.outputAmount = import_sun_sdk_core6.CurrencyAmount.fromFractionalAmount(
+        route.output,
+        tokenAmounts[tokenAmounts.length - 1].numerator,
+        tokenAmounts[tokenAmounts.length - 1].denominator
+      );
+    } else {
+      (0, import_tiny_invariant3.default)(amount.currency.equals(route.output), "OUTPUT");
+      tokenAmounts[tokenAmounts.length - 1] = amount.wrapped;
+      for (let i = route.path.length - 1; i > 0; i -= 1) {
+        const pair = route.pairs[i - 1];
+        const [inputAmount] = pair.getInputAmount(tokenAmounts[i].wrapped);
+        tokenAmounts[i - 1] = inputAmount;
+      }
+      this.inputAmount = import_sun_sdk_core6.CurrencyAmount.fromFractionalAmount(route.input, tokenAmounts[0].numerator, tokenAmounts[0].denominator);
+      this.outputAmount = import_sun_sdk_core6.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+    }
+    this.executionPrice = new import_sun_sdk_core6.Price(this.inputAmount.currency, this.outputAmount.currency, this.inputAmount.quotient, this.outputAmount.quotient);
+    this.priceImpact = (0, import_sun_sdk_core6.computePriceImpact)(route.midPrice, this.inputAmount, this.outputAmount);
+  }
+  minimumAmountOut(slippageTolerance) {
+    (0, import_tiny_invariant3.default)(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === import_sun_sdk_core6.TradeType.EXACT_OUTPUT) return this.outputAmount;
+    const slippageAdjustedAmountOut = new import_sun_sdk_core6.Fraction(ONE).subtract(slippageTolerance).multiply(this.outputAmount.quotient).quotient;
+    const clampedAmount = import_jsbi3.default.greaterThan(slippageAdjustedAmountOut, import_jsbi3.default.BigInt(0)) ? slippageAdjustedAmountOut : import_jsbi3.default.BigInt(0);
+    return import_sun_sdk_core6.CurrencyAmount.fromRawAmount(this.outputAmount.currency, clampedAmount);
+  }
+  maximumAmountIn(slippageTolerance) {
+    (0, import_tiny_invariant3.default)(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === import_sun_sdk_core6.TradeType.EXACT_INPUT) return this.inputAmount;
+    const slippageAdjustedAmountIn = new import_sun_sdk_core6.Fraction(ONE).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
+    return import_sun_sdk_core6.CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
+  }
+  static bestTradeExactIn(pairs, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
+    (0, import_tiny_invariant3.default)(pairs.length > 0, "PAIRS");
+    (0, import_tiny_invariant3.default)(maxHops > 0, "MAX_HOPS");
+    (0, import_tiny_invariant3.default)(currencyAmountIn === nextAmountIn || currentPairs.length > 0, "INVALID_RECURSION");
+    const amountIn = nextAmountIn.wrapped;
+    const tokenOut = currencyOut.wrapped;
+    for (let i = 0; i < pairs.length; i += 1) {
+      const pair = pairs[i];
+      if (!pair.token0.equals(amountIn.currency) && !pair.token1.equals(amountIn.currency)) continue;
+      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO)) continue;
+      let amountOut;
+      try {
+        ;
+        [amountOut] = pair.getOutputAmount(amountIn);
+      } catch (error) {
+        if (error.isInsufficientInputAmountError) continue;
+        throw error;
+      }
+      if (amountOut.currency.equals(tokenOut)) {
+        (0, import_sun_sdk_core6.sortedInsert)(
+          bestTrades,
+          new _Trade(new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut), currencyAmountIn, import_sun_sdk_core6.TradeType.EXACT_INPUT),
+          maxNumResults,
+          tradeComparator
+        );
+      } else if (maxHops > 1 && pairs.length > 1) {
+        const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1));
+        _Trade.bestTradeExactIn(
+          pairsExcludingThisPair,
+          currencyAmountIn,
+          currencyOut,
+          { maxNumResults, maxHops: maxHops - 1 },
+          [...currentPairs, pair],
+          amountOut,
+          bestTrades
+        );
+      }
+    }
+    return bestTrades;
+  }
+  worstExecutionPrice(slippageTolerance) {
+    return new import_sun_sdk_core6.Price(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.maximumAmountIn(slippageTolerance).quotient,
+      this.minimumAmountOut(slippageTolerance).quotient
+    );
+  }
+  static bestTradeExactOut(pairs, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
+    (0, import_tiny_invariant3.default)(pairs.length > 0, "PAIRS");
+    (0, import_tiny_invariant3.default)(maxHops > 0, "MAX_HOPS");
+    (0, import_tiny_invariant3.default)(currencyAmountOut === nextAmountOut || currentPairs.length > 0, "INVALID_RECURSION");
+    const amountOut = nextAmountOut.wrapped;
+    const tokenIn = currencyIn.wrapped;
+    for (let i = 0; i < pairs.length; i += 1) {
+      const pair = pairs[i];
+      if (!pair.token0.equals(amountOut.currency) && !pair.token1.equals(amountOut.currency)) continue;
+      if (pair.reserve0.equalTo(ZERO) || pair.reserve1.equalTo(ZERO)) continue;
+      let amountIn;
+      try {
+        ;
+        [amountIn] = pair.getInputAmount(amountOut);
+      } catch (error) {
+        if (error.isInsufficientReservesError) continue;
+        throw error;
+      }
+      if (amountIn.currency.equals(tokenIn)) {
+        (0, import_sun_sdk_core6.sortedInsert)(
+          bestTrades,
+          new _Trade(new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency), currencyAmountOut, import_sun_sdk_core6.TradeType.EXACT_OUTPUT),
+          maxNumResults,
+          tradeComparator
+        );
+      } else if (maxHops > 1 && pairs.length > 1) {
+        const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1));
+        _Trade.bestTradeExactOut(
+          pairsExcludingThisPair,
+          currencyIn,
+          currencyAmountOut,
+          { maxNumResults, maxHops: maxHops - 1 },
+          [pair, ...currentPairs],
+          amountIn,
+          bestTrades
+        );
+      }
+    }
+    return bestTrades;
+  }
+};
+
+// src/reads.ts
+var import_sun_sdk_chains3 = require("@sun-protocol/sun-sdk-chains");
+var V2_PAIR_READ_SELECTORS = {
+  getReserves: "getReserves()",
+  totalSupply: "totalSupply()",
+  kLast: "kLast()",
+  balanceOf: "balanceOf(address)",
+  allowance: "allowance(address,address)"
+};
+var V2_FACTORY_READ_SELECTORS = {
+  getPair: "getPair(address,address)",
+  feeTo: "feeTo()"
+};
+var V2_ROUTER_READ_SELECTORS = {
+  getAmountsOut: "getAmountsOut(uint256,address[])",
+  getAmountsIn: "getAmountsIn(uint256,address[])",
+  isAllowedTradingPair: "isAllowedTradingPair(address,address)"
+};
+function valueOf2(value) {
+  return value.toString();
+}
+function buildV2PairReservesRead(pair) {
+  return {
+    target: pair,
+    functionSelector: V2_PAIR_READ_SELECTORS.getReserves,
+    metadata: { protocol: "sunswap-v2", contract: "pair", action: "get-reserves" }
+  };
+}
+function buildV2PairTotalSupplyRead(pair) {
+  return {
+    target: pair,
+    functionSelector: V2_PAIR_READ_SELECTORS.totalSupply,
+    metadata: { protocol: "sunswap-v2", contract: "pair", action: "total-supply" }
+  };
+}
+function buildV2PairKLastRead(pair) {
+  return {
+    target: pair,
+    functionSelector: V2_PAIR_READ_SELECTORS.kLast,
+    outputs: [{ type: "uint256", name: "kLast" }],
+    metadata: { protocol: "sunswap-v2", contract: "pair", action: "k-last" }
+  };
+}
+function buildV2PairBalanceRead(pair, owner) {
+  return {
+    target: pair,
+    functionSelector: V2_PAIR_READ_SELECTORS.balanceOf,
+    parameters: [{ type: "address", value: owner }],
+    metadata: { protocol: "sunswap-v2", contract: "pair", action: "balance-of" }
+  };
+}
+function buildV2PairAllowanceRead(pair, owner, spender) {
+  return {
+    target: pair,
+    functionSelector: V2_PAIR_READ_SELECTORS.allowance,
+    parameters: [
+      { type: "address", value: owner },
+      { type: "address", value: spender }
+    ],
+    metadata: { protocol: "sunswap-v2", contract: "pair", action: "allowance" }
+  };
+}
+function routerTarget2(params) {
+  return params.router ?? (0, import_sun_sdk_chains3.getContractAddress)(params.network, "sunswapV2Router");
+}
+function factoryTarget(params) {
+  return params.factory ?? (0, import_sun_sdk_chains3.getContractAddress)(params.network, "sunswapV2Factory");
+}
+function buildV2FactoryPairRead(params) {
+  return {
+    target: factoryTarget(params),
+    functionSelector: V2_FACTORY_READ_SELECTORS.getPair,
+    parameters: [
+      { type: "address", value: params.tokenA },
+      { type: "address", value: params.tokenB }
+    ],
+    outputs: [{ type: "address", name: "pair" }],
+    metadata: {
+      protocol: "sunswap-v2",
+      contract: "factory",
+      action: "get-pair",
+      network: params.network
+    }
+  };
+}
+function buildV2FactoryFeeToRead(params) {
+  return {
+    target: factoryTarget(params),
+    functionSelector: V2_FACTORY_READ_SELECTORS.feeTo,
+    outputs: [{ type: "address", name: "feeTo" }],
+    metadata: {
+      protocol: "sunswap-v2",
+      contract: "factory",
+      action: "fee-to",
+      network: params.network
+    }
+  };
+}
+function buildV2RouterAmountsOutRead(params) {
+  return {
+    target: routerTarget2(params),
+    functionSelector: V2_ROUTER_READ_SELECTORS.getAmountsOut,
+    parameters: [
+      { type: "uint256", value: valueOf2(params.amountIn) },
+      { type: "address[]", value: params.path }
+    ],
+    metadata: {
+      protocol: "sunswap-v2",
+      contract: "router",
+      action: "get-amounts-out",
+      network: params.network
+    }
+  };
+}
+function buildV2RouterAmountsInRead(params) {
+  return {
+    target: routerTarget2(params),
+    functionSelector: V2_ROUTER_READ_SELECTORS.getAmountsIn,
+    parameters: [
+      { type: "uint256", value: valueOf2(params.amountOut) },
+      { type: "address[]", value: params.path }
+    ],
+    metadata: {
+      protocol: "sunswap-v2",
+      contract: "router",
+      action: "get-amounts-in",
+      network: params.network
+    }
+  };
+}
+function buildV2RouterAllowedTradingPairRead(params) {
+  return {
+    target: routerTarget2(params),
+    functionSelector: V2_ROUTER_READ_SELECTORS.isAllowedTradingPair,
+    parameters: [
+      { type: "address", value: params.tokenA },
+      { type: "address", value: params.tokenB }
+    ],
+    metadata: {
+      protocol: "sunswap-v2",
+      contract: "router",
+      action: "is-allowed-trading-pair",
+      network: params.network
+    }
+  };
+}
+function normalizeV2ReserveResult(result) {
+  return {
+    reserve0: valueOf2(result[0]),
+    reserve1: valueOf2(result[1])
+  };
+}
+function normalizeV2AmountsResult(result) {
+  const values = Array.isArray(result?.amounts) ? result.amounts : Array.isArray(result) ? result : [];
+  return values.map((value) => valueOf2(value));
+}
+
+// src/router.ts
+var import_sun_sdk_core7 = require("@sun-protocol/sun-sdk-core");
+var import_tiny_invariant4 = __toESM(require("tiny-invariant"), 1);
+function toHex(currencyAmount) {
+  return `0x${currencyAmount.quotient.toString(16)}`;
+}
+var ZERO_HEX = "0x0";
+var Router = class {
+  constructor() {
+  }
+  static swapCallParameters(trade, options) {
+    const etherIn = trade.inputAmount.currency.isNative;
+    const etherOut = trade.outputAmount.currency.isNative;
+    (0, import_tiny_invariant4.default)(!(etherIn && etherOut), "ETHER_IN_OUT");
+    (0, import_tiny_invariant4.default)(!("ttl" in options) || options.ttl > 0, "TTL");
+    const to = (0, import_sun_sdk_core7.validateAndParseAddress)(options.recipient);
+    const amountIn = toHex(trade.maximumAmountIn(options.allowedSlippage));
+    const amountOut = toHex(trade.minimumAmountOut(options.allowedSlippage));
+    const path = trade.route.path.map((token) => token.address);
+    const deadline = "ttl" in options ? `0x${(Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
+    const useFeeOnTransfer = Boolean(options.feeOnTransfer);
+    let methodName = "";
+    let args = [];
+    let value = ZERO_HEX;
+    switch (trade.tradeType) {
+      case import_sun_sdk_core7.TradeType.EXACT_INPUT:
+        if (etherIn) {
+          methodName = useFeeOnTransfer ? "swapExactETHForTokensSupportingFeeOnTransferTokens" : "swapExactETHForTokens";
+          args = [amountOut, path, to, deadline];
+          value = amountIn;
+        } else if (etherOut) {
+          methodName = useFeeOnTransfer ? "swapExactTokensForETHSupportingFeeOnTransferTokens" : "swapExactTokensForETH";
+          args = [amountIn, amountOut, path, to, deadline];
+          value = ZERO_HEX;
+        } else {
+          methodName = useFeeOnTransfer ? "swapExactTokensForTokensSupportingFeeOnTransferTokens" : "swapExactTokensForTokens";
+          args = [amountIn, amountOut, path, to, deadline];
+          value = ZERO_HEX;
+        }
+        break;
+      case import_sun_sdk_core7.TradeType.EXACT_OUTPUT:
+        (0, import_tiny_invariant4.default)(!useFeeOnTransfer, "EXACT_OUT_FOT");
+        if (etherIn) {
+          methodName = "swapETHForExactTokens";
+          args = [amountOut, path, to, deadline];
+          value = amountIn;
+        } else if (etherOut) {
+          methodName = "swapTokensForExactETH";
+          args = [amountOut, amountIn, path, to, deadline];
+          value = ZERO_HEX;
+        } else {
+          methodName = "swapTokensForExactTokens";
+          args = [amountOut, amountIn, path, to, deadline];
+          value = ZERO_HEX;
+        }
+        break;
+    }
+    return { methodName, args, value };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASIS_POINTS,
+  FACTORY_ADDRESS,
+  FACTORY_ADDRESS_MAP,
+  FIVE,
+  INIT_CODE_HASH,
+  INIT_CODE_HASH_MAP,
+  InsufficientInputAmountError,
+  InsufficientReservesError,
+  MINIMUM_LIQUIDITY,
+  ONE,
+  ONE_HUNDRED_PERCENT,
+  Pair,
+  Route,
+  Router,
+  Trade,
+  V2_FACTORY_READ_SELECTORS,
+  V2_INIT_CODE_HASH,
+  V2_PAIR_READ_SELECTORS,
+  V2_ROUTER_READ_SELECTORS,
+  V2_ROUTER_SELECTORS,
+  ZERO,
+  ZERO_PERCENT,
+  _1000,
+  _997,
+  applyV2SlippageMin,
+  buildV2AddLiquidityAction,
+  buildV2AddLiquidityEthAction,
+  buildV2FactoryFeeToRead,
+  buildV2FactoryPairRead,
+  buildV2LpApproveAction,
+  buildV2PairAllowanceRead,
+  buildV2PairBalanceRead,
+  buildV2PairKLastRead,
+  buildV2PairReservesRead,
+  buildV2PairTotalSupplyRead,
+  buildV2RemoveLiquidityAction,
+  buildV2RemoveLiquidityEthAction,
+  buildV2RouterAllowedTradingPairRead,
+  buildV2RouterAmountsInRead,
+  buildV2RouterAmountsOutRead,
+  buildV2SwapEthForExactTokensAction,
+  buildV2SwapExactEthForTokensAction,
+  buildV2SwapExactTokensForEthAction,
+  buildV2SwapExactTokensForTokensAction,
+  buildV2SwapTokensForExactEthAction,
+  buildV2SwapTokensForExactTokensAction,
+  computePairAddress,
+  computeV2PairAddress,
+  createV2PairKey,
+  evmHexToTronAddress,
+  getV2AddLiquidityMinimums,
+  getV2RemoveLiquidityMinimums,
+  inputOutputComparator,
+  normalizeV2AmountsResult,
+  normalizeV2ReserveResult,
+  quoteV2LiquidityAmount,
+  sortV2Tokens,
+  tradeComparator,
+  tronAddressToEvmHex,
+  tronCreate2Address
+});
+//# sourceMappingURL=index.cjs.map