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

package/dist/index.js

@@ -0,0 +1,3024 @@
+// src/actions.ts
+import { getContractAddress } from "@sun-protocol/sun-sdk-chains";
+import {
+  assertTronAddress,
+  createContractCallAction
+} from "@sun-protocol/sun-sdk-core";
+import JSBI from "jsbi";
+var V3_POSITION_MANAGER_SELECTORS = {
+  createAndInitializePoolIfNecessary: "createAndInitializePoolIfNecessary(address,address,uint24,uint160)",
+  mint: "mint((address,address,uint24,int24,int24,uint256,uint256,uint256,uint256,address,uint256))",
+  increaseLiquidity: "increaseLiquidity((uint256,uint256,uint256,uint256,uint256,uint256))",
+  decreaseLiquidity: "decreaseLiquidity((uint256,uint128,uint256,uint256,uint256))",
+  collect: "collect((uint256,address,uint128,uint128))"
+};
+var MaxUint128 = JSBI.subtract(JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(128)), JSBI.BigInt(1));
+function positionManagerTarget(params) {
+  return params.positionManager ?? getContractAddress(params.network, "sunswapV3PositionManager");
+}
+function valueOf(value) {
+  return JSBI.BigInt(value).toString();
+}
+function actionId(params, suffix) {
+  return params.id ?? `sunswap-v3-${suffix}-${params.network}`;
+}
+function buildV3CreatePoolAction(params) {
+  return createContractCallAction({
+    id: actionId(params, "create-pool"),
+    target: positionManagerTarget(params),
+    functionSelector: V3_POSITION_MANAGER_SELECTORS.createAndInitializePoolIfNecessary,
+    parameters: [
+      { type: "address", value: params.pool.token0.address },
+      { type: "address", value: params.pool.token1.address },
+      { type: "uint24", value: params.pool.fee },
+      { type: "uint160", value: params.pool.sqrtRatioX96.toString() }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV3MintPositionAction(params) {
+  const { amount0: amount0Desired, amount1: amount1Desired } = params.position.mintAmounts;
+  return createContractCallAction({
+    id: actionId(params, "mint"),
+    target: positionManagerTarget(params),
+    functionSelector: V3_POSITION_MANAGER_SELECTORS.mint,
+    parameters: [
+      {
+        type: "tuple",
+        value: {
+          token0: params.position.pool.token0.address,
+          token1: params.position.pool.token1.address,
+          fee: params.position.pool.fee,
+          tickLower: params.position.tickLower,
+          tickUpper: params.position.tickUpper,
+          amount0Desired: amount0Desired.toString(),
+          amount1Desired: amount1Desired.toString(),
+          amount0Min: valueOf(params.amount0Min),
+          amount1Min: valueOf(params.amount1Min),
+          recipient: assertTronAddress(params.recipient),
+          deadline: valueOf(params.deadline)
+        }
+      }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV3IncreaseLiquidityAction(params) {
+  const { amount0: amount0Desired, amount1: amount1Desired } = params.position.mintAmounts;
+  return createContractCallAction({
+    id: actionId(params, "increase-liquidity"),
+    target: positionManagerTarget(params),
+    functionSelector: V3_POSITION_MANAGER_SELECTORS.increaseLiquidity,
+    parameters: [
+      {
+        type: "tuple",
+        value: {
+          tokenId: valueOf(params.tokenId),
+          amount0Desired: amount0Desired.toString(),
+          amount1Desired: amount1Desired.toString(),
+          amount0Min: valueOf(params.amount0Min),
+          amount1Min: valueOf(params.amount1Min),
+          deadline: valueOf(params.deadline)
+        }
+      }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV3DecreaseLiquidityAction(params) {
+  return createContractCallAction({
+    id: actionId(params, "decrease-liquidity"),
+    target: positionManagerTarget(params),
+    functionSelector: V3_POSITION_MANAGER_SELECTORS.decreaseLiquidity,
+    parameters: [
+      {
+        type: "tuple",
+        value: {
+          tokenId: valueOf(params.tokenId),
+          liquidity: valueOf(params.liquidity),
+          amount0Min: valueOf(params.amount0Min),
+          amount1Min: valueOf(params.amount1Min),
+          deadline: valueOf(params.deadline)
+        }
+      }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+function buildV3CollectAction(params) {
+  return createContractCallAction({
+    id: actionId(params, "collect"),
+    target: positionManagerTarget(params),
+    functionSelector: V3_POSITION_MANAGER_SELECTORS.collect,
+    parameters: [
+      {
+        type: "tuple",
+        value: {
+          tokenId: valueOf(params.tokenId),
+          recipient: assertTronAddress(params.recipient),
+          amount0Max: valueOf(params.amount0Max ?? MaxUint128),
+          amount1Max: valueOf(params.amount1Max ?? MaxUint128)
+        }
+      }
+    ],
+    ...params.feeLimit !== void 0 ? { feeLimit: params.feeLimit } : {}
+  });
+}
+
+// src/abi.ts
+var V3_POOL_SLOT0_ABI = {
+  type: "function",
+  name: "slot0",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [
+    { name: "sqrtPriceX96", type: "uint160" },
+    { name: "tick", type: "int24" },
+    { name: "observationIndex", type: "uint16" },
+    { name: "observationCardinality", type: "uint16" },
+    { name: "observationCardinalityNext", type: "uint16" },
+    { name: "feeProtocol", type: "uint8" },
+    { name: "unlocked", type: "bool" }
+  ]
+};
+var V3_POOL_LIQUIDITY_ABI = {
+  type: "function",
+  name: "liquidity",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [{ type: "uint128" }]
+};
+var V3_POOL_FEE_ABI = {
+  type: "function",
+  name: "fee",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [{ type: "uint24" }]
+};
+var V3_POOL_TICK_SPACING_ABI = {
+  type: "function",
+  name: "tickSpacing",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [{ type: "int24" }]
+};
+var V3_POSITION_MANAGER_POSITIONS_ABI = {
+  type: "function",
+  name: "positions",
+  stateMutability: "view",
+  inputs: [{ name: "tokenId", type: "uint256" }],
+  outputs: [
+    { name: "nonce", type: "uint96" },
+    { name: "operator", type: "address" },
+    { name: "token0", type: "address" },
+    { name: "token1", type: "address" },
+    { name: "fee", type: "uint24" },
+    { name: "tickLower", type: "int24" },
+    { name: "tickUpper", type: "int24" },
+    { name: "liquidity", type: "uint128" },
+    { name: "feeGrowthInside0LastX128", type: "uint256" },
+    { name: "feeGrowthInside1LastX128", type: "uint256" },
+    { name: "tokensOwed0", type: "uint128" },
+    { name: "tokensOwed1", type: "uint128" }
+  ]
+};
+var V3_POSITION_MANAGER_OWNER_OF_ABI = {
+  type: "function",
+  name: "ownerOf",
+  stateMutability: "view",
+  inputs: [{ name: "tokenId", type: "uint256" }],
+  outputs: [{ type: "address" }]
+};
+var V3_POSITION_MANAGER_GET_APPROVED_ABI = {
+  type: "function",
+  name: "getApproved",
+  stateMutability: "view",
+  inputs: [{ name: "tokenId", type: "uint256" }],
+  outputs: [{ type: "address" }]
+};
+var V3_POSITION_MANAGER_IS_APPROVED_FOR_ALL_ABI = {
+  type: "function",
+  name: "isApprovedForAll",
+  stateMutability: "view",
+  inputs: [
+    { name: "owner", type: "address" },
+    { name: "operator", type: "address" }
+  ],
+  outputs: [{ type: "bool" }]
+};
+
+// src/constants.ts
+var IS_TVM = true;
+var FACTORY_ADDRESS = "0xc2708485c99cd8cf058de1a9a7e3c2d8261a995c";
+var ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+var POOL_INIT_CODE_HASH = "0xba928a717d71946d75999ef1adef801a79cd34a20efecea8b2876b85f5f49580";
+var FeeAmount = /* @__PURE__ */ ((FeeAmount2) => {
+  FeeAmount2[FeeAmount2["LOWEST"] = 100] = "LOWEST";
+  FeeAmount2[FeeAmount2["LOW"] = 500] = "LOW";
+  FeeAmount2[FeeAmount2["MEDIUM"] = 3e3] = "MEDIUM";
+  FeeAmount2[FeeAmount2["HIGH"] = 1e4] = "HIGH";
+  return FeeAmount2;
+})(FeeAmount || {});
+var TICK_SPACINGS = {
+  [100 /* LOWEST */]: 1,
+  [500 /* LOW */]: 10,
+  [3e3 /* MEDIUM */]: 60,
+  [1e4 /* HIGH */]: 200
+};
+
+// src/entities/pool.ts
+import { CurrencyAmount, Price as Price2, Token } from "@sun-protocol/sun-sdk-core";
+import JSBI17 from "jsbi";
+import invariant7 from "tiny-invariant";
+
+// src/internal-constants.ts
+import JSBI2 from "jsbi";
+var NEGATIVE_ONE = JSBI2.BigInt(-1);
+var ZERO = JSBI2.BigInt(0);
+var ONE = JSBI2.BigInt(1);
+var Q96 = JSBI2.exponentiate(JSBI2.BigInt(2), JSBI2.BigInt(96));
+var Q192 = JSBI2.exponentiate(Q96, JSBI2.BigInt(2));
+
+// src/utils/computePoolAddress.ts
+import { defaultAbiCoder } from "@ethersproject/abi";
+import { getCreate2Address } from "@ethersproject/address";
+import { keccak256 as keccak2562 } from "@ethersproject/solidity";
+
+// src/utils/computeTronPoolAddress.ts
+import { getAddress } from "@ethersproject/address";
+import { concat, hexDataLength, hexDataSlice } from "@ethersproject/bytes";
+import { keccak256 } from "@ethersproject/keccak256";
+import { Logger } from "@ethersproject/logger";
+var logger = new Logger("");
+function getTronCreate2Address(from, salt, initCodeHash) {
+  if (hexDataLength(salt) !== 32) {
+    logger.throwArgumentError("salt must be 32 bytes", "salt", salt);
+  }
+  if (hexDataLength(initCodeHash) !== 32) {
+    logger.throwArgumentError("initCodeHash must be 32 bytes", "initCodeHash", initCodeHash);
+  }
+  return getAddress(hexDataSlice(keccak256(concat(["0x41", getAddress(from), salt, initCodeHash])), 12));
+}
+
+// src/utils/computePoolAddress.ts
+function computePoolAddress({
+  factoryAddress,
+  tokenA,
+  tokenB,
+  fee,
+  initCodeHashManualOverride
+}) {
+  const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
+  if (IS_TVM) {
+    return getTronCreate2Address(
+      factoryAddress,
+      keccak2562(
+        ["bytes"],
+        [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]
+      ),
+      initCodeHashManualOverride ?? POOL_INIT_CODE_HASH
+    );
+  } else {
+    return getCreate2Address(
+      factoryAddress,
+      keccak2562(
+        ["bytes"],
+        [defaultAbiCoder.encode(["address", "address", "uint24"], [token0.address, token1.address, fee])]
+      ),
+      initCodeHashManualOverride ?? POOL_INIT_CODE_HASH
+    );
+  }
+}
+
+// src/utils/liquidityMath.ts
+import JSBI3 from "jsbi";
+var LiquidityMath = class {
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static addDelta(x, y) {
+    if (JSBI3.lessThan(y, ZERO)) {
+      return JSBI3.subtract(x, JSBI3.multiply(y, NEGATIVE_ONE));
+    } else {
+      return JSBI3.add(x, y);
+    }
+  }
+};
+
+// src/utils/swapMath.ts
+import JSBI6 from "jsbi";
+
+// src/utils/full-math.ts
+import JSBI4 from "jsbi";
+var FullMath = class {
+  constructor() {
+  }
+  static mulDivRoundingUp(a, b, denominator) {
+    const product = JSBI4.multiply(a, b);
+    let result = JSBI4.divide(product, denominator);
+    if (JSBI4.notEqual(JSBI4.remainder(product, denominator), ZERO)) result = JSBI4.add(result, ONE);
+    return result;
+  }
+};
+
+// src/utils/sqrt-price-math.ts
+import { MaxUint256 } from "@sun-protocol/sun-sdk-core";
+import JSBI5 from "jsbi";
+import invariant from "tiny-invariant";
+var MaxUint160 = JSBI5.subtract(JSBI5.exponentiate(JSBI5.BigInt(2), JSBI5.BigInt(160)), ONE);
+function multiplyIn256(x, y) {
+  const product = JSBI5.multiply(x, y);
+  return JSBI5.bitwiseAnd(product, MaxUint256);
+}
+function addIn256(x, y) {
+  const sum = JSBI5.add(x, y);
+  return JSBI5.bitwiseAnd(sum, MaxUint256);
+}
+var SqrtPriceMath = class {
+  constructor() {
+  }
+  static getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
+    if (JSBI5.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+      ;
+      [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    const numerator1 = JSBI5.leftShift(liquidity, JSBI5.BigInt(96));
+    const numerator2 = JSBI5.subtract(sqrtRatioBX96, sqrtRatioAX96);
+    return roundUp ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96) : JSBI5.divide(JSBI5.divide(JSBI5.multiply(numerator1, numerator2), sqrtRatioBX96), sqrtRatioAX96);
+  }
+  static getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
+    if (JSBI5.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+      ;
+      [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    return roundUp ? FullMath.mulDivRoundingUp(liquidity, JSBI5.subtract(sqrtRatioBX96, sqrtRatioAX96), Q96) : JSBI5.divide(JSBI5.multiply(liquidity, JSBI5.subtract(sqrtRatioBX96, sqrtRatioAX96)), Q96);
+  }
+  static getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
+    invariant(JSBI5.greaterThan(sqrtPX96, ZERO));
+    invariant(JSBI5.greaterThan(liquidity, ZERO));
+    return zeroForOne ? this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true) : this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);
+  }
+  static getNextSqrtPriceFromOutput(sqrtPX96, liquidity, amountOut, zeroForOne) {
+    invariant(JSBI5.greaterThan(sqrtPX96, ZERO));
+    invariant(JSBI5.greaterThan(liquidity, ZERO));
+    return zeroForOne ? this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false) : this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);
+  }
+  static getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add) {
+    if (JSBI5.equal(amount, ZERO)) return sqrtPX96;
+    const numerator1 = JSBI5.leftShift(liquidity, JSBI5.BigInt(96));
+    if (add) {
+      const product2 = multiplyIn256(amount, sqrtPX96);
+      if (JSBI5.equal(JSBI5.divide(product2, amount), sqrtPX96)) {
+        const denominator2 = addIn256(numerator1, product2);
+        if (JSBI5.greaterThanOrEqual(denominator2, numerator1)) {
+          return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator2);
+        }
+      }
+      return FullMath.mulDivRoundingUp(numerator1, ONE, JSBI5.add(JSBI5.divide(numerator1, sqrtPX96), amount));
+    }
+    const product = multiplyIn256(amount, sqrtPX96);
+    invariant(JSBI5.equal(JSBI5.divide(product, amount), sqrtPX96));
+    invariant(JSBI5.greaterThan(numerator1, product));
+    const denominator = JSBI5.subtract(numerator1, product);
+    return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
+  }
+  static getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add) {
+    if (add) {
+      const quotient2 = JSBI5.lessThanOrEqual(amount, MaxUint160) ? JSBI5.divide(JSBI5.leftShift(amount, JSBI5.BigInt(96)), liquidity) : JSBI5.divide(JSBI5.multiply(amount, Q96), liquidity);
+      return JSBI5.add(sqrtPX96, quotient2);
+    }
+    const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity);
+    invariant(JSBI5.greaterThan(sqrtPX96, quotient));
+    return JSBI5.subtract(sqrtPX96, quotient);
+  }
+};
+
+// src/utils/swapMath.ts
+var MAX_FEE = JSBI6.exponentiate(JSBI6.BigInt(10), JSBI6.BigInt(6));
+var SwapMath = class {
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static computeSwapStep(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, amountRemaining, feePips) {
+    const returnValues = {};
+    const zeroForOne = JSBI6.greaterThanOrEqual(sqrtRatioCurrentX96, sqrtRatioTargetX96);
+    const exactIn = JSBI6.greaterThanOrEqual(amountRemaining, ZERO);
+    if (exactIn) {
+      const amountRemainingLessFee = JSBI6.divide(
+        JSBI6.multiply(amountRemaining, JSBI6.subtract(MAX_FEE, JSBI6.BigInt(feePips))),
+        MAX_FEE
+      );
+      returnValues.amountIn = zeroForOne ? SqrtPriceMath.getAmount0Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, true) : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, true);
+      if (JSBI6.greaterThanOrEqual(amountRemainingLessFee, returnValues.amountIn)) {
+        returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
+      } else {
+        returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          amountRemainingLessFee,
+          zeroForOne
+        );
+      }
+    } else {
+      returnValues.amountOut = zeroForOne ? SqrtPriceMath.getAmount1Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, false) : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, false);
+      if (JSBI6.greaterThanOrEqual(JSBI6.multiply(amountRemaining, NEGATIVE_ONE), returnValues.amountOut)) {
+        returnValues.sqrtRatioNextX96 = sqrtRatioTargetX96;
+      } else {
+        returnValues.sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          JSBI6.multiply(amountRemaining, NEGATIVE_ONE),
+          zeroForOne
+        );
+      }
+    }
+    const max = JSBI6.equal(sqrtRatioTargetX96, returnValues.sqrtRatioNextX96);
+    if (zeroForOne) {
+      returnValues.amountIn = max && exactIn ? returnValues.amountIn : SqrtPriceMath.getAmount0Delta(returnValues.sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, true);
+      returnValues.amountOut = max && !exactIn ? returnValues.amountOut : SqrtPriceMath.getAmount1Delta(returnValues.sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, false);
+    } else {
+      returnValues.amountIn = max && exactIn ? returnValues.amountIn : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, returnValues.sqrtRatioNextX96, liquidity, true);
+      returnValues.amountOut = max && !exactIn ? returnValues.amountOut : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, returnValues.sqrtRatioNextX96, liquidity, false);
+    }
+    if (!exactIn && JSBI6.greaterThan(returnValues.amountOut, JSBI6.multiply(amountRemaining, NEGATIVE_ONE))) {
+      returnValues.amountOut = JSBI6.multiply(amountRemaining, NEGATIVE_ONE);
+    }
+    if (exactIn && JSBI6.notEqual(returnValues.sqrtRatioNextX96, sqrtRatioTargetX96)) {
+      returnValues.feeAmount = JSBI6.subtract(amountRemaining, returnValues.amountIn);
+    } else {
+      returnValues.feeAmount = FullMath.mulDivRoundingUp(
+        returnValues.amountIn,
+        JSBI6.BigInt(feePips),
+        JSBI6.subtract(MAX_FEE, JSBI6.BigInt(feePips))
+      );
+    }
+    return [returnValues.sqrtRatioNextX96, returnValues.amountIn, returnValues.amountOut, returnValues.feeAmount];
+  }
+};
+
+// src/utils/tick-math.ts
+import { MaxUint256 as MaxUint2562 } from "@sun-protocol/sun-sdk-core";
+import JSBI8 from "jsbi";
+import invariant3 from "tiny-invariant";
+
+// src/utils/most-significant-bit.ts
+import JSBI7 from "jsbi";
+import invariant2 from "tiny-invariant";
+var MAX_SAFE_INTEGER = JSBI7.BigInt(Number.MAX_SAFE_INTEGER);
+function invariantSafeInteger(value) {
+  invariant2(Number.isSafeInteger(value), "NUMERIC_FAULT");
+}
+function mostSignificantBit(x) {
+  invariant2(JSBI7.greaterThan(x, JSBI7.BigInt(0)), "ZERO");
+  invariant2(JSBI7.lessThanOrEqual(x, JSBI7.exponentiate(JSBI7.BigInt(2), JSBI7.BigInt(256))), "MAX");
+  let msb = 0;
+  for (const [power, min] of [
+    [128, "0x100000000000000000000000000000000"],
+    [64, "0x10000000000000000"],
+    [32, "0x100000000"],
+    [16, "0x10000"],
+    [8, "0x100"],
+    [4, "0x10"],
+    [2, "0x4"],
+    [1, "0x2"]
+  ]) {
+    if (JSBI7.greaterThanOrEqual(x, JSBI7.BigInt(min))) {
+      x = JSBI7.signedRightShift(x, JSBI7.BigInt(power));
+      msb += power;
+    }
+  }
+  invariantSafeInteger(msb);
+  invariant2(JSBI7.lessThanOrEqual(JSBI7.BigInt(msb), MAX_SAFE_INTEGER), "NUMERIC_FAULT");
+  return msb;
+}
+
+// src/utils/tick-math.ts
+function mulShift(value, multiplier) {
+  return JSBI8.signedRightShift(JSBI8.multiply(value, JSBI8.BigInt(multiplier)), JSBI8.BigInt(128));
+}
+var Q32 = JSBI8.exponentiate(JSBI8.BigInt(2), JSBI8.BigInt(32));
+var TickMath = class _TickMath {
+  constructor() {
+  }
+  static MIN_TICK = -887272;
+  static MAX_TICK = -_TickMath.MIN_TICK;
+  static MIN_SQRT_RATIO = JSBI8.BigInt("4295128739");
+  static MAX_SQRT_RATIO = JSBI8.BigInt("1461446703485210103287273052203988822378723970342");
+  static getSqrtRatioAtTick(tick) {
+    invariant3(tick >= _TickMath.MIN_TICK && tick <= _TickMath.MAX_TICK && Number.isInteger(tick), "TICK");
+    const absTick = tick < 0 ? tick * -1 : tick;
+    let ratio = (absTick & 1) !== 0 ? JSBI8.BigInt("0xfffcb933bd6fad37aa2d162d1a594001") : JSBI8.BigInt("0x100000000000000000000000000000000");
+    if ((absTick & 2) !== 0) ratio = mulShift(ratio, "0xfff97272373d413259a46990580e213a");
+    if ((absTick & 4) !== 0) ratio = mulShift(ratio, "0xfff2e50f5f656932ef12357cf3c7fdcc");
+    if ((absTick & 8) !== 0) ratio = mulShift(ratio, "0xffe5caca7e10e4e61c3624eaa0941cd0");
+    if ((absTick & 16) !== 0) ratio = mulShift(ratio, "0xffcb9843d60f6159c9db58835c926644");
+    if ((absTick & 32) !== 0) ratio = mulShift(ratio, "0xff973b41fa98c081472e6896dfb254c0");
+    if ((absTick & 64) !== 0) ratio = mulShift(ratio, "0xff2ea16466c96a3843ec78b326b52861");
+    if ((absTick & 128) !== 0) ratio = mulShift(ratio, "0xfe5dee046a99a2a811c461f1969c3053");
+    if ((absTick & 256) !== 0) ratio = mulShift(ratio, "0xfcbe86c7900a88aedcffc83b479aa3a4");
+    if ((absTick & 512) !== 0) ratio = mulShift(ratio, "0xf987a7253ac413176f2b074cf7815e54");
+    if ((absTick & 1024) !== 0) ratio = mulShift(ratio, "0xf3392b0822b70005940c7a398e4b70f3");
+    if ((absTick & 2048) !== 0) ratio = mulShift(ratio, "0xe7159475a2c29b7443b29c7fa6e889d9");
+    if ((absTick & 4096) !== 0) ratio = mulShift(ratio, "0xd097f3bdfd2022b8845ad8f792aa5825");
+    if ((absTick & 8192) !== 0) ratio = mulShift(ratio, "0xa9f746462d870fdf8a65dc1f90e061e5");
+    if ((absTick & 16384) !== 0) ratio = mulShift(ratio, "0x70d869a156d2a1b890bb3df62baf32f7");
+    if ((absTick & 32768) !== 0) ratio = mulShift(ratio, "0x31be135f97d08fd981231505542fcfa6");
+    if ((absTick & 65536) !== 0) ratio = mulShift(ratio, "0x9aa508b5b7a84e1c677de54f3e99bc9");
+    if ((absTick & 131072) !== 0) ratio = mulShift(ratio, "0x5d6af8dedb81196699c329225ee604");
+    if ((absTick & 262144) !== 0) ratio = mulShift(ratio, "0x2216e584f5fa1ea926041bedfe98");
+    if ((absTick & 524288) !== 0) ratio = mulShift(ratio, "0x48a170391f7dc42444e8fa2");
+    if (tick > 0) ratio = JSBI8.divide(MaxUint2562, ratio);
+    return JSBI8.greaterThan(JSBI8.remainder(ratio, Q32), ZERO) ? JSBI8.add(JSBI8.divide(ratio, Q32), ONE) : JSBI8.divide(ratio, Q32);
+  }
+  static getTickAtSqrtRatio(sqrtRatioX96) {
+    invariant3(
+      JSBI8.greaterThanOrEqual(sqrtRatioX96, _TickMath.MIN_SQRT_RATIO) && JSBI8.lessThan(sqrtRatioX96, _TickMath.MAX_SQRT_RATIO),
+      "SQRT_RATIO"
+    );
+    const sqrtRatioX128 = JSBI8.leftShift(sqrtRatioX96, JSBI8.BigInt(32));
+    const msb = mostSignificantBit(sqrtRatioX128);
+    let r;
+    if (JSBI8.greaterThanOrEqual(JSBI8.BigInt(msb), JSBI8.BigInt(128))) {
+      r = JSBI8.signedRightShift(sqrtRatioX128, JSBI8.BigInt(msb - 127));
+    } else {
+      r = JSBI8.leftShift(sqrtRatioX128, JSBI8.BigInt(127 - msb));
+    }
+    let log2 = JSBI8.leftShift(JSBI8.subtract(JSBI8.BigInt(msb), JSBI8.BigInt(128)), JSBI8.BigInt(64));
+    for (let i = 0; i < 14; i++) {
+      r = JSBI8.signedRightShift(JSBI8.multiply(r, r), JSBI8.BigInt(127));
+      const f = JSBI8.signedRightShift(r, JSBI8.BigInt(128));
+      log2 = JSBI8.bitwiseOr(log2, JSBI8.leftShift(f, JSBI8.BigInt(63 - i)));
+      r = JSBI8.signedRightShift(r, f);
+    }
+    const logSqrt10001 = JSBI8.multiply(log2, JSBI8.BigInt("255738958999603826347141"));
+    const tickLow = JSBI8.toNumber(
+      JSBI8.signedRightShift(
+        JSBI8.subtract(logSqrt10001, JSBI8.BigInt("3402992956809132418596140100660247210")),
+        JSBI8.BigInt(128)
+      )
+    );
+    const tickHigh = JSBI8.toNumber(
+      JSBI8.signedRightShift(
+        JSBI8.add(logSqrt10001, JSBI8.BigInt("291339464771989622907027621153398088495")),
+        JSBI8.BigInt(128)
+      )
+    );
+    return tickLow === tickHigh ? tickLow : JSBI8.lessThanOrEqual(_TickMath.getSqrtRatioAtTick(tickHigh), sqrtRatioX96) ? tickHigh : tickLow;
+  }
+};
+
+// src/entities/tickDataProvider.ts
+var NoTickDataProvider = class _NoTickDataProvider {
+  static ERROR_MESSAGE = "No tick data provider was given";
+  async getTick(_tick) {
+    throw new Error(_NoTickDataProvider.ERROR_MESSAGE);
+  }
+  async nextInitializedTickWithinOneWord(_tick, _lte, _tickSpacing) {
+    throw new Error(_NoTickDataProvider.ERROR_MESSAGE);
+  }
+};
+
+// src/utils/tickList.ts
+import JSBI9 from "jsbi";
+import invariant4 from "tiny-invariant";
+
+// src/utils/isSorted.ts
+function isSorted(list, comparator) {
+  for (let i = 0; i < list.length - 1; i++) {
+    if (comparator(list[i], list[i + 1]) > 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/utils/tickList.ts
+function tickComparator(a, b) {
+  return a.index - b.index;
+}
+var TickList = class _TickList {
+  /**
+   * Cannot be constructed
+   */
+  constructor() {
+  }
+  static validateList(ticks, tickSpacing) {
+    invariant4(tickSpacing > 0, "TICK_SPACING_NONZERO");
+    invariant4(
+      ticks.every(({ index }) => index % tickSpacing === 0),
+      "TICK_SPACING"
+    );
+    invariant4(
+      JSBI9.equal(
+        ticks.reduce((accumulator, { liquidityNet }) => JSBI9.add(accumulator, liquidityNet), ZERO),
+        ZERO
+      ),
+      "ZERO_NET"
+    );
+    invariant4(isSorted(ticks, tickComparator), "SORTED");
+  }
+  static isBelowSmallest(ticks, tick) {
+    invariant4(ticks.length > 0, "LENGTH");
+    return tick < ticks[0].index;
+  }
+  static isAtOrAboveLargest(ticks, tick) {
+    invariant4(ticks.length > 0, "LENGTH");
+    return tick >= ticks[ticks.length - 1].index;
+  }
+  static getTick(ticks, index) {
+    const tick = ticks[this.binarySearch(ticks, index)];
+    invariant4(tick.index === index, "NOT_CONTAINED");
+    return tick;
+  }
+  /**
+   * Finds the largest tick in the list of ticks that is less than or equal to tick
+   * @param ticks list of ticks
+   * @param tick tick to find the largest tick that is less than or equal to tick
+   * @private
+   */
+  static binarySearch(ticks, tick) {
+    invariant4(!this.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+    let l = 0;
+    let r = ticks.length - 1;
+    let i;
+    while (true) {
+      i = Math.floor((l + r) / 2);
+      if (ticks[i].index <= tick && (i === ticks.length - 1 || ticks[i + 1].index > tick)) {
+        return i;
+      }
+      if (ticks[i].index < tick) {
+        l = i + 1;
+      } else {
+        r = i - 1;
+      }
+    }
+  }
+  static nextInitializedTick(ticks, tick, lte) {
+    if (lte) {
+      invariant4(!_TickList.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+      if (_TickList.isAtOrAboveLargest(ticks, tick)) {
+        return ticks[ticks.length - 1];
+      }
+      const index = this.binarySearch(ticks, tick);
+      return ticks[index];
+    } else {
+      invariant4(!this.isAtOrAboveLargest(ticks, tick), "AT_OR_ABOVE_LARGEST");
+      if (this.isBelowSmallest(ticks, tick)) {
+        return ticks[0];
+      }
+      const index = this.binarySearch(ticks, tick);
+      return ticks[index + 1];
+    }
+  }
+  static nextInitializedTickWithinOneWord(ticks, tick, lte, tickSpacing) {
+    const compressed = Math.floor(tick / tickSpacing);
+    if (lte) {
+      const wordPos = compressed >> 8;
+      const minimum = (wordPos << 8) * tickSpacing;
+      if (_TickList.isBelowSmallest(ticks, tick)) {
+        return [minimum, false];
+      }
+      const index = _TickList.nextInitializedTick(ticks, tick, lte).index;
+      const nextInitializedTick = Math.max(minimum, index);
+      return [nextInitializedTick, nextInitializedTick === index];
+    } else {
+      const wordPos = compressed + 1 >> 8;
+      const maximum = ((wordPos + 1 << 8) - 1) * tickSpacing;
+      if (this.isAtOrAboveLargest(ticks, tick)) {
+        return [maximum, false];
+      }
+      const index = this.nextInitializedTick(ticks, tick, lte).index;
+      const nextInitializedTick = Math.min(maximum, index);
+      return [nextInitializedTick, nextInitializedTick === index];
+    }
+  }
+};
+
+// src/entities/tick.ts
+import JSBI16 from "jsbi";
+import invariant6 from "tiny-invariant";
+
+// src/utils/calldata.ts
+import JSBI10 from "jsbi";
+function toHex(bigintIsh) {
+  const bigInt = JSBI10.BigInt(bigintIsh);
+  let hex = bigInt.toString(16);
+  if (hex.length % 2 !== 0) {
+    hex = `0${hex}`;
+  }
+  return `0x${hex}`;
+}
+
+// src/utils/encode-sqrt-ratio-x96.ts
+import { sqrt } from "@sun-protocol/sun-sdk-core";
+import JSBI11 from "jsbi";
+function encodeSqrtRatioX96(amount1, amount0) {
+  const numerator = JSBI11.leftShift(JSBI11.BigInt(amount1), JSBI11.BigInt(192));
+  const denominator = JSBI11.BigInt(amount0);
+  const ratioX192 = JSBI11.divide(numerator, denominator);
+  return sqrt(ratioX192);
+}
+
+// src/utils/encodeRouteToPath.ts
+import { pack } from "@ethersproject/solidity";
+function encodeRouteToPath(route, exactOutput) {
+  const firstInputToken = route.input.wrapped;
+  const { path, types } = route.pools.reduce(
+    ({ inputToken, path: path2, types: types2 }, pool, index) => {
+      const outputToken = pool.token0.equals(inputToken) ? pool.token1 : pool.token0;
+      if (index === 0) {
+        return {
+          inputToken: outputToken,
+          types: ["address", "uint24", "address"],
+          path: [inputToken.address, pool.fee, outputToken.address]
+        };
+      } else {
+        return {
+          inputToken: outputToken,
+          types: [...types2, "uint24", "address"],
+          path: [...path2, pool.fee, outputToken.address]
+        };
+      }
+    },
+    { inputToken: firstInputToken, path: [], types: [] }
+  );
+  return exactOutput ? pack(types.reverse(), path.reverse()) : pack(types, path);
+}
+
+// src/utils/max-liquidity-for-amounts.ts
+import JSBI12 from "jsbi";
+function maxLiquidityForAmount0Imprecise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
+  if (JSBI12.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    ;
+    [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+  }
+  const intermediate = JSBI12.divide(JSBI12.multiply(sqrtRatioAX96, sqrtRatioBX96), Q96);
+  return JSBI12.divide(JSBI12.multiply(JSBI12.BigInt(amount0), intermediate), JSBI12.subtract(sqrtRatioBX96, sqrtRatioAX96));
+}
+function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
+  if (JSBI12.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    ;
+    [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+  }
+  const numerator = JSBI12.multiply(JSBI12.multiply(JSBI12.BigInt(amount0), sqrtRatioAX96), sqrtRatioBX96);
+  const denominator = JSBI12.multiply(Q96, JSBI12.subtract(sqrtRatioBX96, sqrtRatioAX96));
+  return JSBI12.divide(numerator, denominator);
+}
+function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
+  if (JSBI12.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    ;
+    [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+  }
+  return JSBI12.divide(JSBI12.multiply(JSBI12.BigInt(amount1), Q96), JSBI12.subtract(sqrtRatioBX96, sqrtRatioAX96));
+}
+function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX96, amount0, amount1, useFullPrecision) {
+  if (JSBI12.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+    ;
+    [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+  }
+  const maxLiquidityForAmount0 = useFullPrecision ? maxLiquidityForAmount0Precise : maxLiquidityForAmount0Imprecise;
+  if (JSBI12.lessThanOrEqual(sqrtRatioCurrentX96, sqrtRatioAX96)) {
+    return maxLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
+  }
+  if (JSBI12.lessThan(sqrtRatioCurrentX96, sqrtRatioBX96)) {
+    const liquidity0 = maxLiquidityForAmount0(sqrtRatioCurrentX96, sqrtRatioBX96, amount0);
+    const liquidity1 = maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioCurrentX96, amount1);
+    return JSBI12.lessThan(liquidity0, liquidity1) ? liquidity0 : liquidity1;
+  }
+  return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
+}
+
+// src/utils/nearest-usable-tick.ts
+import invariant5 from "tiny-invariant";
+function nearestUsableTick(tick, tickSpacing) {
+  invariant5(Number.isInteger(tick) && Number.isInteger(tickSpacing), "INTEGERS");
+  invariant5(tickSpacing > 0, "TICK_SPACING");
+  invariant5(tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK, "TICK_BOUND");
+  const rounded = Math.round(tick / tickSpacing) * tickSpacing;
+  if (rounded < TickMath.MIN_TICK) return rounded + tickSpacing;
+  if (rounded > TickMath.MAX_TICK) return rounded - tickSpacing;
+  return rounded;
+}
+
+// src/utils/position.ts
+import JSBI13 from "jsbi";
+var Q128 = JSBI13.exponentiate(JSBI13.BigInt(2), JSBI13.BigInt(128));
+var PositionLibrary = class {
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  // replicates the portions of Position#update required to compute unaccounted fees
+  static getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
+    const tokensOwed0 = JSBI13.divide(
+      JSBI13.multiply(subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128), liquidity),
+      Q128
+    );
+    const tokensOwed1 = JSBI13.divide(
+      JSBI13.multiply(subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128), liquidity),
+      Q128
+    );
+    return [tokensOwed0, tokensOwed1];
+  }
+};
+
+// src/utils/priceTickConversions.ts
+import { Price } from "@sun-protocol/sun-sdk-core";
+import JSBI14 from "jsbi";
+function tickToPrice(baseToken, quoteToken, tick) {
+  const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
+  const ratioX192 = JSBI14.multiply(sqrtRatioX96, sqrtRatioX96);
+  return baseToken.sortsBefore(quoteToken) ? new Price(baseToken, quoteToken, Q192, ratioX192) : new Price(baseToken, quoteToken, ratioX192, Q192);
+}
+function priceToClosestTick(price) {
+  const sorted = price.baseCurrency.sortsBefore(price.quoteCurrency);
+  const sqrtRatioX96 = sorted ? encodeSqrtRatioX96(price.numerator, price.denominator) : encodeSqrtRatioX96(price.denominator, price.numerator);
+  let tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
+  const nextTickPrice = tickToPrice(price.baseCurrency, price.quoteCurrency, tick + 1);
+  if (sorted) {
+    if (!price.lessThan(nextTickPrice)) {
+      tick++;
+    }
+  } else {
+    if (!price.greaterThan(nextTickPrice)) {
+      tick++;
+    }
+  }
+  return tick;
+}
+
+// src/utils/tickLibrary.ts
+import JSBI15 from "jsbi";
+var Q256 = JSBI15.exponentiate(JSBI15.BigInt(2), JSBI15.BigInt(256));
+function subIn256(x, y) {
+  const difference = JSBI15.subtract(x, y);
+  if (JSBI15.lessThan(difference, ZERO)) {
+    return JSBI15.add(Q256, difference);
+  } else {
+    return difference;
+  }
+}
+var TickLibrary = class {
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static getFeeGrowthInside(feeGrowthOutsideLower, feeGrowthOutsideUpper, tickLower, tickUpper, tickCurrent, feeGrowthGlobal0X128, feeGrowthGlobal1X128) {
+    let feeGrowthBelow0X128;
+    let feeGrowthBelow1X128;
+    if (tickCurrent >= tickLower) {
+      feeGrowthBelow0X128 = feeGrowthOutsideLower.feeGrowthOutside0X128;
+      feeGrowthBelow1X128 = feeGrowthOutsideLower.feeGrowthOutside1X128;
+    } else {
+      feeGrowthBelow0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideLower.feeGrowthOutside0X128);
+      feeGrowthBelow1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideLower.feeGrowthOutside1X128);
+    }
+    let feeGrowthAbove0X128;
+    let feeGrowthAbove1X128;
+    if (tickCurrent < tickUpper) {
+      feeGrowthAbove0X128 = feeGrowthOutsideUpper.feeGrowthOutside0X128;
+      feeGrowthAbove1X128 = feeGrowthOutsideUpper.feeGrowthOutside1X128;
+    } else {
+      feeGrowthAbove0X128 = subIn256(feeGrowthGlobal0X128, feeGrowthOutsideUpper.feeGrowthOutside0X128);
+      feeGrowthAbove1X128 = subIn256(feeGrowthGlobal1X128, feeGrowthOutsideUpper.feeGrowthOutside1X128);
+    }
+    return [
+      subIn256(subIn256(feeGrowthGlobal0X128, feeGrowthBelow0X128), feeGrowthAbove0X128),
+      subIn256(subIn256(feeGrowthGlobal1X128, feeGrowthBelow1X128), feeGrowthAbove1X128)
+    ];
+  }
+};
+
+// src/utils/ticks.ts
+import { SDK_ERROR_CODES, sdkInvariant } from "@sun-protocol/sun-sdk-core";
+function isSupportedFeeAmount(fee) {
+  return Object.prototype.hasOwnProperty.call(TICK_SPACINGS, fee);
+}
+function getTickSpacing(fee) {
+  sdkInvariant(isSupportedFeeAmount(fee), SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Unsupported V3 fee tier", { fee });
+  return TICK_SPACINGS[fee];
+}
+function validateTickSpacing(tickSpacing) {
+  sdkInvariant(Number.isInteger(tickSpacing), SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Tick spacing must be an integer", {
+    tickSpacing
+  });
+  sdkInvariant(tickSpacing > 0, SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Tick spacing must be positive", { tickSpacing });
+  return tickSpacing;
+}
+function validateTickRange(tickLower, tickUpper, tickSpacing) {
+  validateTickSpacing(tickSpacing);
+  sdkInvariant(Number.isInteger(tickLower), SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Lower tick must be an integer", {
+    tickLower
+  });
+  sdkInvariant(Number.isInteger(tickUpper), SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Upper tick must be an integer", {
+    tickUpper
+  });
+  sdkInvariant(tickLower < tickUpper, SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Lower tick must be below upper tick", {
+    tickLower,
+    tickUpper
+  });
+  sdkInvariant(tickLower >= TickMath.MIN_TICK, SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Lower tick is below min tick", {
+    tickLower,
+    minTick: TickMath.MIN_TICK
+  });
+  sdkInvariant(tickUpper <= TickMath.MAX_TICK, SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Upper tick is above max tick", {
+    tickUpper,
+    maxTick: TickMath.MAX_TICK
+  });
+  sdkInvariant(tickLower % tickSpacing === 0, SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Lower tick is not usable", {
+    tickLower,
+    tickSpacing
+  });
+  sdkInvariant(tickUpper % tickSpacing === 0, SDK_ERROR_CODES.SDK_INVALID_ARGUMENT, "Upper tick is not usable", {
+    tickUpper,
+    tickSpacing
+  });
+  return { tickLower, tickUpper };
+}
+function validateTickRangeForFee(tickLower, tickUpper, fee) {
+  const tickSpacing = getTickSpacing(fee);
+  return { ...validateTickRange(tickLower, tickUpper, tickSpacing), tickSpacing };
+}
+
+// src/entities/tick.ts
+var Tick = class {
+  index;
+  liquidityGross;
+  liquidityNet;
+  constructor({ index, liquidityGross, liquidityNet }) {
+    invariant6(index >= TickMath.MIN_TICK && index <= TickMath.MAX_TICK, "TICK");
+    this.index = index;
+    this.liquidityGross = JSBI16.BigInt(liquidityGross);
+    this.liquidityNet = JSBI16.BigInt(liquidityNet);
+  }
+};
+
+// src/entities/tickListDataProvider.ts
+var TickListDataProvider = class {
+  ticks;
+  constructor(ticks, tickSpacing) {
+    const ticksMapped = ticks.map((t) => t instanceof Tick ? t : new Tick(t));
+    TickList.validateList(ticksMapped, tickSpacing);
+    this.ticks = ticksMapped;
+  }
+  async getTick(tick) {
+    return TickList.getTick(this.ticks, tick);
+  }
+  async nextInitializedTickWithinOneWord(tick, lte, tickSpacing) {
+    return TickList.nextInitializedTickWithinOneWord(this.ticks, tick, lte, tickSpacing);
+  }
+};
+
+// src/entities/pool.ts
+var NO_TICK_DATA_PROVIDER_DEFAULT = new NoTickDataProvider();
+var Pool = class _Pool {
+  token0;
+  token1;
+  fee;
+  sqrtRatioX96;
+  liquidity;
+  tickCurrent;
+  tickDataProvider;
+  _tickSpacing;
+  isV4;
+  _token0Price;
+  _token1Price;
+  static getAddress(tokenA, tokenB, fee, initCodeHashManualOverride, factoryAddressOverride) {
+    return computePoolAddress({
+      factoryAddress: factoryAddressOverride ?? FACTORY_ADDRESS,
+      fee,
+      tokenA,
+      tokenB,
+      ...initCodeHashManualOverride !== void 0 ? { initCodeHashManualOverride } : {}
+    });
+  }
+  constructor(tokenAOrArgs, tokenB, fee, sqrtRatioX96, liquidity, tickCurrent, ticks = NO_TICK_DATA_PROVIDER_DEFAULT, isV4, tickSpacing) {
+    const args = tokenAOrArgs instanceof Token ? { tokenA: tokenAOrArgs, tokenB, fee, sqrtRatioX96, liquidity, tickCurrent, ticks, isV4, tickSpacing } : tokenAOrArgs;
+    const resolvedTicks = args.ticks ?? NO_TICK_DATA_PROVIDER_DEFAULT;
+    const { fee: resolvedFee } = args;
+    if (!args.isV4) {
+      invariant7(Number.isInteger(resolvedFee) && resolvedFee < 1e6, "FEE");
+    }
+    this.isV4 = args.isV4;
+    this._tickSpacing = args.tickSpacing;
+    const tickCurrentSqrtRatioX96 = TickMath.getSqrtRatioAtTick(args.tickCurrent);
+    const nextTickSqrtRatioX96 = TickMath.getSqrtRatioAtTick(args.tickCurrent + 1);
+    invariant7(
+      JSBI17.greaterThanOrEqual(JSBI17.BigInt(args.sqrtRatioX96), tickCurrentSqrtRatioX96) && JSBI17.lessThanOrEqual(JSBI17.BigInt(args.sqrtRatioX96), nextTickSqrtRatioX96),
+      "PRICE_BOUNDS"
+    );
+    [this.token0, this.token1] = args.tokenA.sortsBefore(args.tokenB) ? [args.tokenA, args.tokenB] : [args.tokenB, args.tokenA];
+    this.fee = resolvedFee;
+    this.sqrtRatioX96 = JSBI17.BigInt(args.sqrtRatioX96);
+    this.liquidity = JSBI17.BigInt(args.liquidity);
+    this.tickCurrent = args.tickCurrent;
+    if (args.isV4) {
+      this.tickDataProvider = Array.isArray(resolvedTicks) ? new TickListDataProvider(resolvedTicks, args.tickSpacing) : resolvedTicks;
+    } else {
+      this.tickDataProvider = Array.isArray(resolvedTicks) ? new TickListDataProvider(resolvedTicks, TICK_SPACINGS[resolvedFee]) : resolvedTicks;
+    }
+  }
+  /**
+   * Returns true if the token is either token0 or token1
+   * @param token The token to check
+   * @returns True if token is either token0 or token
+   */
+  involvesToken(token) {
+    return token.equals(this.token0) || token.equals(this.token1);
+  }
+  /**
+   * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+   */
+  get token0Price() {
+    return this._token0Price ?? (this._token0Price = new Price2(
+      this.token0,
+      this.token1,
+      Q192,
+      JSBI17.multiply(this.sqrtRatioX96, this.sqrtRatioX96)
+    ));
+  }
+  /**
+   * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+   */
+  get token1Price() {
+    return this._token1Price ?? (this._token1Price = new Price2(
+      this.token1,
+      this.token0,
+      JSBI17.multiply(this.sqrtRatioX96, this.sqrtRatioX96),
+      Q192
+    ));
+  }
+  /**
+   * Return the price of the given token in terms of the other token in the pool.
+   * @param token The token to return price of
+   * @returns The price of the given token, in terms of the other.
+   */
+  priceOf(token) {
+    invariant7(this.involvesToken(token), "TOKEN");
+    return token.equals(this.token0) ? this.token0Price : this.token1Price;
+  }
+  /**
+   * Returns the chain ID of the tokens in the pool.
+   */
+  get chainId() {
+    return this.token0.chainId;
+  }
+  /**
+   * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+   * @param inputAmount The input amount for which to quote the output amount
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
+   * @returns The output amount and the pool with updated state
+   */
+  async getOutputAmount(inputAmount, sqrtPriceLimitX96) {
+    invariant7(this.involvesToken(inputAmount.currency), "TOKEN");
+    const zeroForOne = inputAmount.currency.equals(this.token0);
+    const { amountCalculated: outputAmount, sqrtRatioX96, liquidity, tickCurrent } = await this.swap(
+      zeroForOne,
+      inputAmount.quotient,
+      sqrtPriceLimitX96
+    );
+    const outputToken = zeroForOne ? this.token1 : this.token0;
+    return [
+      CurrencyAmount.fromRawAmount(outputToken, JSBI17.multiply(outputAmount, NEGATIVE_ONE)),
+      new _Pool(
+        this.token0,
+        this.token1,
+        this.fee,
+        sqrtRatioX96,
+        liquidity,
+        tickCurrent,
+        this.tickDataProvider,
+        this.isV4,
+        this._tickSpacing
+      )
+    ];
+  }
+  /**
+   * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+   * @param outputAmount the output amount for which to quote the input amount
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+   * @returns The input amount and the pool with updated state
+   */
+  async getInputAmount(outputAmount, sqrtPriceLimitX96) {
+    invariant7(outputAmount.currency.isToken && this.involvesToken(outputAmount.currency), "TOKEN");
+    const zeroForOne = outputAmount.currency.equals(this.token1);
+    const { amountCalculated: inputAmount, sqrtRatioX96, liquidity, tickCurrent } = await this.swap(
+      zeroForOne,
+      JSBI17.multiply(outputAmount.quotient, NEGATIVE_ONE),
+      sqrtPriceLimitX96
+    );
+    const inputToken = zeroForOne ? this.token0 : this.token1;
+    return [
+      CurrencyAmount.fromRawAmount(inputToken, inputAmount),
+      new _Pool(
+        this.token0,
+        this.token1,
+        this.fee,
+        sqrtRatioX96,
+        liquidity,
+        tickCurrent,
+        this.tickDataProvider,
+        this.isV4,
+        this._tickSpacing
+      )
+    ];
+  }
+  /**
+   * Executes a swap
+   * @param zeroForOne Whether the amount in is token0 or token1
+   * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+   * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+   * @returns amountCalculated
+   * @returns sqrtRatioX96
+   * @returns liquidity
+   * @returns tickCurrent
+   */
+  async swap(zeroForOne, amountSpecified, sqrtPriceLimitX96) {
+    if (!sqrtPriceLimitX96)
+      sqrtPriceLimitX96 = zeroForOne ? JSBI17.add(TickMath.MIN_SQRT_RATIO, ONE) : JSBI17.subtract(TickMath.MAX_SQRT_RATIO, ONE);
+    if (zeroForOne) {
+      invariant7(JSBI17.greaterThan(sqrtPriceLimitX96, TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
+      invariant7(JSBI17.lessThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
+    } else {
+      invariant7(JSBI17.lessThan(sqrtPriceLimitX96, TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
+      invariant7(JSBI17.greaterThan(sqrtPriceLimitX96, this.sqrtRatioX96), "RATIO_CURRENT");
+    }
+    const exactInput = JSBI17.greaterThanOrEqual(amountSpecified, ZERO);
+    const state = {
+      amountSpecifiedRemaining: amountSpecified,
+      amountCalculated: ZERO,
+      sqrtPriceX96: this.sqrtRatioX96,
+      tick: this.tickCurrent,
+      liquidity: this.liquidity
+    };
+    while (JSBI17.notEqual(state.amountSpecifiedRemaining, ZERO) && state.sqrtPriceX96 != sqrtPriceLimitX96) {
+      const step = {};
+      step.sqrtPriceStartX96 = state.sqrtPriceX96;
+      [step.tickNext, step.initialized] = await this.tickDataProvider.nextInitializedTickWithinOneWord(
+        state.tick,
+        zeroForOne,
+        this.tickSpacing
+      );
+      if (step.tickNext < TickMath.MIN_TICK) {
+        step.tickNext = TickMath.MIN_TICK;
+      } else if (step.tickNext > TickMath.MAX_TICK) {
+        step.tickNext = TickMath.MAX_TICK;
+      }
+      step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
+      [state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount] = SwapMath.computeSwapStep(
+        state.sqrtPriceX96,
+        (zeroForOne ? JSBI17.lessThan(step.sqrtPriceNextX96, sqrtPriceLimitX96) : JSBI17.greaterThan(step.sqrtPriceNextX96, sqrtPriceLimitX96)) ? sqrtPriceLimitX96 : step.sqrtPriceNextX96,
+        state.liquidity,
+        state.amountSpecifiedRemaining,
+        this.fee
+      );
+      if (exactInput) {
+        state.amountSpecifiedRemaining = JSBI17.subtract(
+          state.amountSpecifiedRemaining,
+          JSBI17.add(step.amountIn, step.feeAmount)
+        );
+        state.amountCalculated = JSBI17.subtract(state.amountCalculated, step.amountOut);
+      } else {
+        state.amountSpecifiedRemaining = JSBI17.add(state.amountSpecifiedRemaining, step.amountOut);
+        state.amountCalculated = JSBI17.add(state.amountCalculated, JSBI17.add(step.amountIn, step.feeAmount));
+      }
+      if (JSBI17.equal(state.sqrtPriceX96, step.sqrtPriceNextX96)) {
+        if (step.initialized) {
+          let liquidityNet = JSBI17.BigInt((await this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
+          if (zeroForOne) liquidityNet = JSBI17.multiply(liquidityNet, NEGATIVE_ONE);
+          state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
+        }
+        state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
+      } else if (JSBI17.notEqual(state.sqrtPriceX96, step.sqrtPriceStartX96)) {
+        state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
+      }
+    }
+    return {
+      amountCalculated: state.amountCalculated,
+      sqrtRatioX96: state.sqrtPriceX96,
+      liquidity: state.liquidity,
+      tickCurrent: state.tick
+    };
+  }
+  get tickSpacing() {
+    if (this.isV4) {
+      return this._tickSpacing;
+    }
+    return TICK_SPACINGS[this.fee];
+  }
+};
+
+// src/entities/position.ts
+import { MaxUint256 as MaxUint2563, Percent, CurrencyAmount as CurrencyAmount2 } from "@sun-protocol/sun-sdk-core";
+import JSBI18 from "jsbi";
+import invariant8 from "tiny-invariant";
+var Position = class _Position {
+  pool;
+  tickLower;
+  tickUpper;
+  liquidity;
+  // cached resuts for the getters
+  _token0Amount = null;
+  _token1Amount = null;
+  _mintAmounts = null;
+  /**
+   * Constructs a position for a given pool with the given liquidity
+   * @param pool For which pool the liquidity is assigned
+   * @param liquidity The amount of liquidity that is in the position
+   * @param tickLower The lower tick of the position
+   * @param tickUpper The upper tick of the position
+   */
+  constructor({ pool, liquidity, tickLower, tickUpper }) {
+    invariant8(tickLower < tickUpper, "TICK_ORDER");
+    invariant8(tickLower >= TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0, "TICK_LOWER");
+    invariant8(tickUpper <= TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0, "TICK_UPPER");
+    this.pool = pool;
+    this.tickLower = tickLower;
+    this.tickUpper = tickUpper;
+    this.liquidity = JSBI18.BigInt(liquidity);
+  }
+  /**
+   * Returns the price of token0 at the lower tick
+   */
+  get token0PriceLower() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickLower);
+  }
+  /**
+   * Returns the price of token0 at the upper tick
+   */
+  get token0PriceUpper() {
+    return tickToPrice(this.pool.token0, this.pool.token1, this.tickUpper);
+  }
+  /**
+   * Returns the amount of token0 that this position's liquidity could be burned for at the current pool price
+   */
+  get amount0() {
+    if (this._token0Amount === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        this._token0Amount = CurrencyAmount2.fromRawAmount(
+          this.pool.token0,
+          SqrtPriceMath.getAmount0Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            false
+          )
+        );
+      } else if (this.pool.tickCurrent < this.tickUpper) {
+        this._token0Amount = CurrencyAmount2.fromRawAmount(
+          this.pool.token0,
+          SqrtPriceMath.getAmount0Delta(
+            this.pool.sqrtRatioX96,
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            false
+          )
+        );
+      } else {
+        this._token0Amount = CurrencyAmount2.fromRawAmount(this.pool.token0, ZERO);
+      }
+    }
+    return this._token0Amount;
+  }
+  /**
+   * Returns the amount of token1 that this position's liquidity could be burned for at the current pool price
+   */
+  get amount1() {
+    if (this._token1Amount === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        this._token1Amount = CurrencyAmount2.fromRawAmount(this.pool.token1, ZERO);
+      } else if (this.pool.tickCurrent < this.tickUpper) {
+        this._token1Amount = CurrencyAmount2.fromRawAmount(
+          this.pool.token1,
+          SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            this.pool.sqrtRatioX96,
+            this.liquidity,
+            false
+          )
+        );
+      } else {
+        this._token1Amount = CurrencyAmount2.fromRawAmount(
+          this.pool.token1,
+          SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            false
+          )
+        );
+      }
+    }
+    return this._token1Amount;
+  }
+  /**
+   * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+   * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+   * @returns The sqrt ratios after slippage
+   */
+  ratiosAfterSlippage(slippageTolerance) {
+    const priceLower = this.pool.token0Price.asFraction.multiply(new Percent(1).subtract(slippageTolerance));
+    const priceUpper = this.pool.token0Price.asFraction.multiply(slippageTolerance.add(1));
+    let sqrtRatioX96Lower = encodeSqrtRatioX96(priceLower.numerator, priceLower.denominator);
+    if (JSBI18.lessThanOrEqual(sqrtRatioX96Lower, TickMath.MIN_SQRT_RATIO)) {
+      sqrtRatioX96Lower = JSBI18.add(TickMath.MIN_SQRT_RATIO, JSBI18.BigInt(1));
+    }
+    let sqrtRatioX96Upper = encodeSqrtRatioX96(priceUpper.numerator, priceUpper.denominator);
+    if (JSBI18.greaterThanOrEqual(sqrtRatioX96Upper, TickMath.MAX_SQRT_RATIO)) {
+      sqrtRatioX96Upper = JSBI18.subtract(TickMath.MAX_SQRT_RATIO, JSBI18.BigInt(1));
+    }
+    return {
+      sqrtRatioX96Lower,
+      sqrtRatioX96Upper
+    };
+  }
+  /**
+   * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+   * with the given slippage tolerance
+   * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+   * @returns The amounts, with slippage
+   */
+  mintAmountsWithSlippage(slippageTolerance) {
+    const { sqrtRatioX96Upper, sqrtRatioX96Lower } = this.ratiosAfterSlippage(slippageTolerance);
+    const poolLower = new Pool({
+      tokenA: this.pool.token0,
+      tokenB: this.pool.token1,
+      fee: this.pool.fee,
+      sqrtRatioX96: sqrtRatioX96Lower,
+      liquidity: 0,
+      tickCurrent: TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower),
+      ...this.pool.isV4 ? { isV4: true, tickSpacing: this.pool.tickSpacing } : {}
+    });
+    const poolUpper = new Pool({
+      tokenA: this.pool.token0,
+      tokenB: this.pool.token1,
+      fee: this.pool.fee,
+      sqrtRatioX96: sqrtRatioX96Upper,
+      liquidity: 0,
+      tickCurrent: TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper),
+      ...this.pool.isV4 ? { isV4: true, tickSpacing: this.pool.tickSpacing } : {}
+    });
+    const positionThatWillBeCreated = _Position.fromAmounts({
+      pool: this.pool,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper,
+      ...this.mintAmounts,
+      // the mint amounts are what will be passed as calldata
+      useFullPrecision: false
+    });
+    const { amount0 } = new _Position({
+      pool: poolUpper,
+      liquidity: positionThatWillBeCreated.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    }).mintAmounts;
+    const { amount1 } = new _Position({
+      pool: poolLower,
+      liquidity: positionThatWillBeCreated.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    }).mintAmounts;
+    return { amount0, amount1 };
+  }
+  /**
+   * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+   * position with the given slippage tolerance
+   * @param slippageTolerance tolerance of unfavorable slippage from the current price
+   * @returns The amounts, with slippage
+   */
+  burnAmountsWithSlippage(slippageTolerance) {
+    const { sqrtRatioX96Upper, sqrtRatioX96Lower } = this.ratiosAfterSlippage(slippageTolerance);
+    const poolLower = new Pool({
+      tokenA: this.pool.token0,
+      tokenB: this.pool.token1,
+      fee: this.pool.fee,
+      sqrtRatioX96: sqrtRatioX96Lower,
+      liquidity: 0,
+      tickCurrent: TickMath.getTickAtSqrtRatio(sqrtRatioX96Lower),
+      ...this.pool.isV4 ? { isV4: true, tickSpacing: this.pool.tickSpacing } : {}
+    });
+    const poolUpper = new Pool({
+      tokenA: this.pool.token0,
+      tokenB: this.pool.token1,
+      fee: this.pool.fee,
+      sqrtRatioX96: sqrtRatioX96Upper,
+      liquidity: 0,
+      tickCurrent: TickMath.getTickAtSqrtRatio(sqrtRatioX96Upper),
+      ...this.pool.isV4 ? { isV4: true, tickSpacing: this.pool.tickSpacing } : {}
+    });
+    const amount0 = new _Position({
+      pool: poolUpper,
+      liquidity: this.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    }).amount0;
+    const amount1 = new _Position({
+      pool: poolLower,
+      liquidity: this.liquidity,
+      tickLower: this.tickLower,
+      tickUpper: this.tickUpper
+    }).amount1;
+    return { amount0: amount0.quotient, amount1: amount1.quotient };
+  }
+  /**
+   * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+   * the current price for the pool
+   */
+  get mintAmounts() {
+    if (this._mintAmounts === null) {
+      if (this.pool.tickCurrent < this.tickLower) {
+        return {
+          amount0: SqrtPriceMath.getAmount0Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true
+          ),
+          amount1: ZERO
+        };
+      } else if (this.pool.tickCurrent < this.tickUpper) {
+        return {
+          amount0: SqrtPriceMath.getAmount0Delta(
+            this.pool.sqrtRatioX96,
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true
+          ),
+          amount1: SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            this.pool.sqrtRatioX96,
+            this.liquidity,
+            true
+          )
+        };
+      } else {
+        return {
+          amount0: ZERO,
+          amount1: SqrtPriceMath.getAmount1Delta(
+            TickMath.getSqrtRatioAtTick(this.tickLower),
+            TickMath.getSqrtRatioAtTick(this.tickUpper),
+            this.liquidity,
+            true
+          )
+        };
+      }
+    }
+    return this._mintAmounts;
+  }
+  /**
+   * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+   * and the prices at the tick boundaries.
+   * @param pool The pool for which the position should be created
+   * @param tickLower The lower tick of the position
+   * @param tickUpper The upper tick of the position
+   * @param amount0 token0 amount
+   * @param amount1 token1 amount
+   * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+   * not what core can theoretically support
+   * @returns The amount of liquidity for the position
+   */
+  static fromAmounts({
+    pool,
+    tickLower,
+    tickUpper,
+    amount0,
+    amount1,
+    useFullPrecision
+  }) {
+    const sqrtRatioAX96 = TickMath.getSqrtRatioAtTick(tickLower);
+    const sqrtRatioBX96 = TickMath.getSqrtRatioAtTick(tickUpper);
+    return new _Position({
+      pool,
+      tickLower,
+      tickUpper,
+      liquidity: maxLiquidityForAmounts(
+        pool.sqrtRatioX96,
+        sqrtRatioAX96,
+        sqrtRatioBX96,
+        amount0,
+        amount1,
+        useFullPrecision
+      )
+    });
+  }
+  /**
+   * Computes a position with the maximum amount of liquidity received for a given amount of token0, assuming an unlimited amount of token1
+   * @param pool The pool for which the position is created
+   * @param tickLower The lower tick
+   * @param tickUpper The upper tick
+   * @param amount0 The desired amount of token0
+   * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+   * not what core can theoretically support
+   * @returns The position
+   */
+  static fromAmount0({
+    pool,
+    tickLower,
+    tickUpper,
+    amount0,
+    useFullPrecision
+  }) {
+    return _Position.fromAmounts({ pool, tickLower, tickUpper, amount0, amount1: MaxUint2563, useFullPrecision });
+  }
+  /**
+   * Computes a position with the maximum amount of liquidity received for a given amount of token1, assuming an unlimited amount of token0
+   * @param pool The pool for which the position is created
+   * @param tickLower The lower tick
+   * @param tickUpper The upper tick
+   * @param amount1 The desired amount of token1
+   * @returns The position
+   */
+  static fromAmount1({
+    pool,
+    tickLower,
+    tickUpper,
+    amount1
+  }) {
+    return _Position.fromAmounts({ pool, tickLower, tickUpper, amount0: MaxUint2563, amount1, useFullPrecision: true });
+  }
+};
+
+// src/entities/route.ts
+import invariant9 from "tiny-invariant";
+import { Price as Price3 } from "@sun-protocol/sun-sdk-core";
+var Route = class {
+  pools;
+  tokenPath;
+  input;
+  output;
+  _midPrice = null;
+  /**
+   * Creates an instance of route.
+   * @param pools An array of `Pool` objects, ordered by the route the swap will take
+   * @param input The input token
+   * @param output The output token
+   */
+  constructor(pools, input, output) {
+    invariant9(pools.length > 0, "POOLS");
+    const firstPool = pools[0];
+    const chainId = firstPool.chainId;
+    const allOnSameChain = pools.every((pool) => pool.chainId === chainId);
+    invariant9(allOnSameChain, "CHAIN_IDS");
+    const wrappedInput = input.wrapped;
+    invariant9(firstPool.involvesToken(wrappedInput), "INPUT");
+    invariant9(pools[pools.length - 1].involvesToken(output.wrapped), "OUTPUT");
+    const tokenPath = [wrappedInput];
+    for (const [i, pool] of pools.entries()) {
+      const currentInputToken = tokenPath[i];
+      invariant9(currentInputToken.equals(pool.token0) || currentInputToken.equals(pool.token1), "PATH");
+      const nextToken = currentInputToken.equals(pool.token0) ? pool.token1 : pool.token0;
+      tokenPath.push(nextToken);
+    }
+    this.pools = pools;
+    this.tokenPath = tokenPath;
+    this.input = input;
+    this.output = output ?? tokenPath[tokenPath.length - 1];
+  }
+  get chainId() {
+    return this.pools[0].chainId;
+  }
+  /**
+   * Returns the mid price of the route
+   */
+  get midPrice() {
+    if (this._midPrice !== null) return this._midPrice;
+    const price = this.pools.slice(1).reduce(
+      ({ nextInput, price: price2 }, pool) => {
+        return nextInput.equals(pool.token0) ? {
+          nextInput: pool.token1,
+          price: price2.multiply(pool.token0Price)
+        } : {
+          nextInput: pool.token0,
+          price: price2.multiply(pool.token1Price)
+        };
+      },
+      this.pools[0].token0.equals(this.input.wrapped) ? {
+        nextInput: this.pools[0].token1,
+        price: this.pools[0].token0Price
+      } : {
+        nextInput: this.pools[0].token0,
+        price: this.pools[0].token1Price
+      }
+    ).price;
+    return this._midPrice = new Price3(this.input, this.output, price.denominator, price.numerator);
+  }
+};
+
+// src/entities/trade.ts
+import { Fraction, Percent as Percent2, Price as Price4, sortedInsert, CurrencyAmount as CurrencyAmount3, TradeType } from "@sun-protocol/sun-sdk-core";
+import invariant10 from "tiny-invariant";
+function tradeComparator(a, b) {
+  invariant10(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
+  invariant10(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
+  if (a.outputAmount.equalTo(b.outputAmount)) {
+    if (a.inputAmount.equalTo(b.inputAmount)) {
+      const aHops = a.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
+      const bHops = b.swaps.reduce((total, cur) => total + cur.route.tokenPath.length, 0);
+      return aHops - bHops;
+    }
+    if (a.inputAmount.lessThan(b.inputAmount)) {
+      return -1;
+    } else {
+      return 1;
+    }
+  } else {
+    if (a.outputAmount.lessThan(b.outputAmount)) {
+      return 1;
+    } else {
+      return -1;
+    }
+  }
+}
+var Trade = class _Trade {
+  /**
+   * @deprecated Deprecated in favor of 'swaps' property. If the trade consists of multiple routes
+   * this will return an error.
+   *
+   * When the trade consists of just a single route, this returns the route of the trade,
+   * i.e. which pools the trade goes through.
+   */
+  get route() {
+    invariant10(this.swaps.length == 1, "MULTIPLE_ROUTES");
+    return this.swaps[0].route;
+  }
+  /**
+   * The swaps of the trade, i.e. which routes and how much is swapped in each that
+   * make up the trade.
+   */
+  swaps;
+  /**
+   * The type of the trade, either exact in or exact out.
+   */
+  tradeType;
+  /**
+   * The cached result of the input amount computation
+   * @private
+   */
+  _inputAmount;
+  /**
+   * The input amount for the trade assuming no slippage.
+   */
+  get inputAmount() {
+    if (this._inputAmount) {
+      return this._inputAmount;
+    }
+    const inputCurrency = this.swaps[0].inputAmount.currency;
+    const totalInputFromRoutes = this.swaps.map(({ inputAmount }) => inputAmount).reduce((total, cur) => total.add(cur), CurrencyAmount3.fromRawAmount(inputCurrency, 0));
+    this._inputAmount = totalInputFromRoutes;
+    return this._inputAmount;
+  }
+  /**
+   * The cached result of the output amount computation
+   * @private
+   */
+  _outputAmount;
+  /**
+   * The output amount for the trade assuming no slippage.
+   */
+  get outputAmount() {
+    if (this._outputAmount) {
+      return this._outputAmount;
+    }
+    const outputCurrency = this.swaps[0].outputAmount.currency;
+    const totalOutputFromRoutes = this.swaps.map(({ outputAmount }) => outputAmount).reduce((total, cur) => total.add(cur), CurrencyAmount3.fromRawAmount(outputCurrency, 0));
+    this._outputAmount = totalOutputFromRoutes;
+    return this._outputAmount;
+  }
+  /**
+   * The cached result of the computed execution price
+   * @private
+   */
+  _executionPrice;
+  /**
+   * The price expressed in terms of output amount/input amount.
+   */
+  get executionPrice() {
+    return this._executionPrice ?? (this._executionPrice = new Price4(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.inputAmount.quotient,
+      this.outputAmount.quotient
+    ));
+  }
+  /**
+   * The cached result of the price impact computation
+   * @private
+   */
+  _priceImpact;
+  /**
+   * Returns the percent difference between the route's mid price and the price impact
+   */
+  get priceImpact() {
+    if (this._priceImpact) {
+      return this._priceImpact;
+    }
+    let spotOutputAmount = CurrencyAmount3.fromRawAmount(this.outputAmount.currency, 0);
+    for (const { route, inputAmount } of this.swaps) {
+      const midPrice = route.midPrice;
+      spotOutputAmount = spotOutputAmount.add(midPrice.quote(inputAmount));
+    }
+    const priceImpact = spotOutputAmount.subtract(this.outputAmount).divide(spotOutputAmount);
+    this._priceImpact = new Percent2(priceImpact.numerator, priceImpact.denominator);
+    return this._priceImpact;
+  }
+  /**
+   * Constructs an exact in trade with the given amount in and route
+   * @template TInput The input token, either Ether or an ERC-20
+   * @template TOutput The output token, either Ether or an ERC-20
+   * @param route The route of the exact in trade
+   * @param amountIn The amount being passed in
+   * @returns The exact in trade
+   */
+  static async exactIn(route, amountIn) {
+    return _Trade.fromRoute(route, amountIn, TradeType.EXACT_INPUT);
+  }
+  /**
+   * Constructs an exact out trade with the given amount out and route
+   * @template TInput The input token, either Ether or an ERC-20
+   * @template TOutput The output token, either Ether or an ERC-20
+   * @param route The route of the exact out trade
+   * @param amountOut The amount returned by the trade
+   * @returns The exact out trade
+   */
+  static async exactOut(route, amountOut) {
+    return _Trade.fromRoute(route, amountOut, TradeType.EXACT_OUTPUT);
+  }
+  /**
+   * Constructs a trade by simulating swaps through the given route
+   * @template TInput The input token, either Ether or an ERC-20.
+   * @template TOutput The output token, either Ether or an ERC-20.
+   * @template TTradeType The type of the trade, either exact in or exact out.
+   * @param route route to swap through
+   * @param amount the amount specified, either input or output, depending on tradeType
+   * @param tradeType whether the trade is an exact input or exact output swap
+   * @returns The route
+   */
+  static async fromRoute(route, amount, tradeType) {
+    const amounts = new Array(route.tokenPath.length);
+    let inputAmount;
+    let outputAmount;
+    if (tradeType === TradeType.EXACT_INPUT) {
+      invariant10(amount.currency.equals(route.input), "INPUT");
+      amounts[0] = amount.wrapped;
+      for (let i = 0; i < route.tokenPath.length - 1; i++) {
+        const pool = route.pools[i];
+        const [outputAmount2] = await pool.getOutputAmount(amounts[i]);
+        amounts[i + 1] = outputAmount2;
+      }
+      inputAmount = CurrencyAmount3.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+      outputAmount = CurrencyAmount3.fromFractionalAmount(
+        route.output,
+        amounts[amounts.length - 1].numerator,
+        amounts[amounts.length - 1].denominator
+      );
+    } else {
+      invariant10(amount.currency.equals(route.output), "OUTPUT");
+      amounts[amounts.length - 1] = amount.wrapped;
+      for (let i = route.tokenPath.length - 1; i > 0; i--) {
+        const pool = route.pools[i - 1];
+        const [inputAmount2] = await pool.getInputAmount(amounts[i]);
+        amounts[i - 1] = inputAmount2;
+      }
+      inputAmount = CurrencyAmount3.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
+      outputAmount = CurrencyAmount3.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+    }
+    return new _Trade({
+      routes: [{ inputAmount, outputAmount, route }],
+      tradeType
+    });
+  }
+  /**
+   * Constructs a trade from routes by simulating swaps
+   *
+   * @template TInput The input token, either Ether or an ERC-20.
+   * @template TOutput The output token, either Ether or an ERC-20.
+   * @template TTradeType The type of the trade, either exact in or exact out.
+   * @param routes the routes to swap through and how much of the amount should be routed through each
+   * @param tradeType whether the trade is an exact input or exact output swap
+   * @returns The trade
+   */
+  static async fromRoutes(routes, tradeType) {
+    const populatedRoutes = [];
+    for (const { route, amount } of routes) {
+      const amounts = new Array(route.tokenPath.length);
+      let inputAmount;
+      let outputAmount;
+      if (tradeType === TradeType.EXACT_INPUT) {
+        invariant10(amount.currency.equals(route.input), "INPUT");
+        inputAmount = CurrencyAmount3.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
+        amounts[0] = CurrencyAmount3.fromFractionalAmount(route.input.wrapped, amount.numerator, amount.denominator);
+        for (let i = 0; i < route.tokenPath.length - 1; i++) {
+          const pool = route.pools[i];
+          const [outputAmount2] = await pool.getOutputAmount(amounts[i]);
+          amounts[i + 1] = outputAmount2;
+        }
+        outputAmount = CurrencyAmount3.fromFractionalAmount(
+          route.output,
+          amounts[amounts.length - 1].numerator,
+          amounts[amounts.length - 1].denominator
+        );
+      } else {
+        invariant10(amount.currency.equals(route.output), "OUTPUT");
+        outputAmount = CurrencyAmount3.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
+        amounts[amounts.length - 1] = CurrencyAmount3.fromFractionalAmount(
+          route.output.wrapped,
+          amount.numerator,
+          amount.denominator
+        );
+        for (let i = route.tokenPath.length - 1; i > 0; i--) {
+          const pool = route.pools[i - 1];
+          const [inputAmount2] = await pool.getInputAmount(amounts[i]);
+          amounts[i - 1] = inputAmount2;
+        }
+        inputAmount = CurrencyAmount3.fromFractionalAmount(route.input, amounts[0].numerator, amounts[0].denominator);
+      }
+      populatedRoutes.push({ route, inputAmount, outputAmount });
+    }
+    return new _Trade({
+      routes: populatedRoutes,
+      tradeType
+    });
+  }
+  /**
+   * Creates a trade without computing the result of swapping through the route. Useful when you have simulated the trade
+   * elsewhere and do not have any tick data
+   * @template TInput The input token, either Ether or an ERC-20
+   * @template TOutput The output token, either Ether or an ERC-20
+   * @template TTradeType The type of the trade, either exact in or exact out
+   * @param constructorArguments The arguments passed to the trade constructor
+   * @returns The unchecked trade
+   */
+  static createUncheckedTrade(constructorArguments) {
+    return new _Trade({
+      ...constructorArguments,
+      routes: [
+        {
+          inputAmount: constructorArguments.inputAmount,
+          outputAmount: constructorArguments.outputAmount,
+          route: constructorArguments.route
+        }
+      ]
+    });
+  }
+  /**
+   * Creates a trade without computing the result of swapping through the routes. Useful when you have simulated the trade
+   * elsewhere and do not have any tick data
+   * @template TInput The input token, either Ether or an ERC-20
+   * @template TOutput The output token, either Ether or an ERC-20
+   * @template TTradeType The type of the trade, either exact in or exact out
+   * @param constructorArguments The arguments passed to the trade constructor
+   * @returns The unchecked trade
+   */
+  static createUncheckedTradeWithMultipleRoutes(constructorArguments) {
+    return new _Trade(constructorArguments);
+  }
+  /**
+   * Construct a trade by passing in the pre-computed property values
+   * @param routes The routes through which the trade occurs
+   * @param tradeType The type of trade, exact input or exact output
+   */
+  constructor({
+    routes,
+    tradeType
+  }) {
+    const inputCurrency = routes[0].inputAmount.currency;
+    const outputCurrency = routes[0].outputAmount.currency;
+    invariant10(
+      routes.every(({ route }) => inputCurrency.wrapped.equals(route.input.wrapped)),
+      "INPUT_CURRENCY_MATCH"
+    );
+    invariant10(
+      routes.every(({ route }) => outputCurrency.wrapped.equals(route.output.wrapped)),
+      "OUTPUT_CURRENCY_MATCH"
+    );
+    const numPools = routes.map(({ route }) => route.pools.length).reduce((total, cur) => total + cur, 0);
+    const poolAddressSet = /* @__PURE__ */ new Set();
+    for (const { route } of routes) {
+      for (const pool of route.pools) {
+        poolAddressSet.add(Pool.getAddress(pool.token0, pool.token1, pool.fee));
+      }
+    }
+    invariant10(numPools == poolAddressSet.size, "POOLS_DUPLICATED");
+    this.swaps = routes;
+    this.tradeType = tradeType;
+  }
+  /**
+   * Get the minimum amount that must be received from this trade for the given slippage tolerance
+   * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+   * @returns The amount out
+   */
+  minimumAmountOut(slippageTolerance, amountOut = this.outputAmount) {
+    invariant10(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === TradeType.EXACT_OUTPUT) {
+      return amountOut;
+    } else {
+      const slippageAdjustedAmountOut = new Fraction(ONE).add(slippageTolerance).invert().multiply(amountOut.quotient).quotient;
+      return CurrencyAmount3.fromRawAmount(amountOut.currency, slippageAdjustedAmountOut);
+    }
+  }
+  /**
+   * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
+   * @param slippageTolerance The tolerance of unfavorable slippage from the execution price of this trade
+   * @returns The amount in
+   */
+  maximumAmountIn(slippageTolerance, amountIn = this.inputAmount) {
+    invariant10(!slippageTolerance.lessThan(ZERO), "SLIPPAGE_TOLERANCE");
+    if (this.tradeType === TradeType.EXACT_INPUT) {
+      return amountIn;
+    } else {
+      const slippageAdjustedAmountIn = new Fraction(ONE).add(slippageTolerance).multiply(amountIn.quotient).quotient;
+      return CurrencyAmount3.fromRawAmount(amountIn.currency, slippageAdjustedAmountIn);
+    }
+  }
+  /**
+   * Return the execution price after accounting for slippage tolerance
+   * @param slippageTolerance the allowed tolerated slippage
+   * @returns The execution price
+   */
+  worstExecutionPrice(slippageTolerance) {
+    return new Price4(
+      this.inputAmount.currency,
+      this.outputAmount.currency,
+      this.maximumAmountIn(slippageTolerance).quotient,
+      this.minimumAmountOut(slippageTolerance).quotient
+    );
+  }
+  /**
+   * Given a list of pools, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
+   * amount to an output token, making at most `maxHops` hops.
+   * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
+   * the amount in among multiple routes.
+   * @param pools the pools to consider in finding the best trade
+   * @param nextAmountIn exact amount of input currency to spend
+   * @param currencyOut the desired currency out
+   * @param maxNumResults maximum number of results to return
+   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+   * @param currentPools used in recursion; the current list of pools
+   * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
+   * @param bestTrades used in recursion; the current list of best trades
+   * @returns The exact in trade
+   */
+  static async bestTradeExactIn(pools, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPools = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
+    invariant10(pools.length > 0, "POOLS");
+    invariant10(maxHops > 0, "MAX_HOPS");
+    invariant10(currencyAmountIn === nextAmountIn || currentPools.length > 0, "INVALID_RECURSION");
+    const amountIn = nextAmountIn.wrapped;
+    const tokenOut = currencyOut.wrapped;
+    for (let i = 0; i < pools.length; i++) {
+      const pool = pools[i];
+      if (!pool.token0.equals(amountIn.currency) && !pool.token1.equals(amountIn.currency)) continue;
+      let amountOut;
+      try {
+        ;
+        [amountOut] = await pool.getOutputAmount(amountIn);
+      } catch (error) {
+        if (error.isInsufficientInputAmountError) {
+          continue;
+        }
+        throw error;
+      }
+      if (amountOut.currency.isToken && amountOut.currency.equals(tokenOut)) {
+        sortedInsert(
+          bestTrades,
+          await _Trade.fromRoute(
+            new Route([...currentPools, pool], currencyAmountIn.currency, currencyOut),
+            currencyAmountIn,
+            TradeType.EXACT_INPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
+      } else if (maxHops > 1 && pools.length > 1) {
+        const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
+        await _Trade.bestTradeExactIn(
+          poolsExcludingThisPool,
+          currencyAmountIn,
+          currencyOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [...currentPools, pool],
+          amountOut,
+          bestTrades
+        );
+      }
+    }
+    return bestTrades;
+  }
+  /**
+   * similar to the above method but instead targets a fixed output amount
+   * given a list of pools, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
+   * to an output token amount, making at most `maxHops` hops
+   * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
+   * the amount in among multiple routes.
+   * @param pools the pools to consider in finding the best trade
+   * @param currencyIn the currency to spend
+   * @param currencyAmountOut the desired currency amount out
+   * @param nextAmountOut the exact amount of currency out
+   * @param maxNumResults maximum number of results to return
+   * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pool
+   * @param currentPools used in recursion; the current list of pools
+   * @param bestTrades used in recursion; the current list of best trades
+   * @returns The exact out trade
+   */
+  static async bestTradeExactOut(pools, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPools = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
+    invariant10(pools.length > 0, "POOLS");
+    invariant10(maxHops > 0, "MAX_HOPS");
+    invariant10(currencyAmountOut === nextAmountOut || currentPools.length > 0, "INVALID_RECURSION");
+    const amountOut = nextAmountOut.wrapped;
+    const tokenIn = currencyIn.wrapped;
+    for (let i = 0; i < pools.length; i++) {
+      const pool = pools[i];
+      if (!pool.token0.equals(amountOut.currency) && !pool.token1.equals(amountOut.currency)) continue;
+      let amountIn;
+      try {
+        ;
+        [amountIn] = await pool.getInputAmount(amountOut);
+      } catch (error) {
+        if (error.isInsufficientReservesError) {
+          continue;
+        }
+        throw error;
+      }
+      if (amountIn.currency.equals(tokenIn)) {
+        sortedInsert(
+          bestTrades,
+          await _Trade.fromRoute(
+            new Route([pool, ...currentPools], currencyIn, currencyAmountOut.currency),
+            currencyAmountOut,
+            TradeType.EXACT_OUTPUT
+          ),
+          maxNumResults,
+          tradeComparator
+        );
+      } else if (maxHops > 1 && pools.length > 1) {
+        const poolsExcludingThisPool = pools.slice(0, i).concat(pools.slice(i + 1, pools.length));
+        await _Trade.bestTradeExactOut(
+          poolsExcludingThisPool,
+          currencyIn,
+          currencyAmountOut,
+          {
+            maxNumResults,
+            maxHops: maxHops - 1
+          },
+          [pool, ...currentPools],
+          amountIn,
+          bestTrades
+        );
+      }
+    }
+    return bestTrades;
+  }
+};
+
+// src/multicall.ts
+import { Interface } from "@ethersproject/abi";
+
+// src/abi/v3-periphery/IMulticall.json
+var IMulticall_default = {
+  abi: [
+    {
+      type: "function",
+      name: "multicall",
+      stateMutability: "payable",
+      inputs: [{ name: "data", type: "bytes[]" }],
+      outputs: [{ name: "results", type: "bytes[]" }]
+    }
+  ]
+};
+
+// src/multicall.ts
+var Multicall = class _Multicall {
+  static INTERFACE = new Interface(IMulticall_default.abi);
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static encodeMulticall(calldatas) {
+    if (!Array.isArray(calldatas)) {
+      calldatas = [calldatas];
+    }
+    return calldatas.length === 1 ? calldatas[0] : _Multicall.INTERFACE.encodeFunctionData("multicall", [calldatas]);
+  }
+};
+
+// src/nonfungiblePositionManager.ts
+import {
+  CurrencyAmount as CurrencyAmount4,
+  validateAndParseAddress as validateAndParseAddress2
+} from "@sun-protocol/sun-sdk-core";
+import JSBI19 from "jsbi";
+import invariant11 from "tiny-invariant";
+import { Interface as Interface4 } from "@ethersproject/abi";
+
+// src/abi/v3-periphery/NonfungiblePositionManager.json
+var NonfungiblePositionManager_default = {
+  abi: [
+    {
+      type: "function",
+      name: "createAndInitializePoolIfNecessary",
+      stateMutability: "payable",
+      inputs: [
+        { name: "token0", type: "address" },
+        { name: "token1", type: "address" },
+        { name: "fee", type: "uint24" },
+        { name: "sqrtPriceX96", type: "uint160" }
+      ],
+      outputs: [{ name: "pool", type: "address" }]
+    },
+    {
+      type: "function",
+      name: "mint",
+      stateMutability: "payable",
+      inputs: [
+        {
+          name: "params",
+          type: "tuple",
+          components: [
+            { name: "token0", type: "address" },
+            { name: "token1", type: "address" },
+            { name: "fee", type: "uint24" },
+            { name: "tickLower", type: "int24" },
+            { name: "tickUpper", type: "int24" },
+            { name: "amount0Desired", type: "uint256" },
+            { name: "amount1Desired", type: "uint256" },
+            { name: "amount0Min", type: "uint256" },
+            { name: "amount1Min", type: "uint256" },
+            { name: "recipient", type: "address" },
+            { name: "deadline", type: "uint256" }
+          ]
+        }
+      ],
+      outputs: [
+        { name: "tokenId", type: "uint256" },
+        { name: "liquidity", type: "uint128" },
+        { name: "amount0", type: "uint256" },
+        { name: "amount1", type: "uint256" }
+      ]
+    },
+    {
+      type: "function",
+      name: "increaseLiquidity",
+      stateMutability: "payable",
+      inputs: [
+        {
+          name: "params",
+          type: "tuple",
+          components: [
+            { name: "tokenId", type: "uint256" },
+            { name: "amount0Desired", type: "uint256" },
+            { name: "amount1Desired", type: "uint256" },
+            { name: "amount0Min", type: "uint256" },
+            { name: "amount1Min", type: "uint256" },
+            { name: "deadline", type: "uint256" }
+          ]
+        }
+      ],
+      outputs: [
+        { name: "liquidity", type: "uint128" },
+        { name: "amount0", type: "uint256" },
+        { name: "amount1", type: "uint256" }
+      ]
+    },
+    {
+      type: "function",
+      name: "decreaseLiquidity",
+      stateMutability: "payable",
+      inputs: [
+        {
+          name: "params",
+          type: "tuple",
+          components: [
+            { name: "tokenId", type: "uint256" },
+            { name: "liquidity", type: "uint128" },
+            { name: "amount0Min", type: "uint256" },
+            { name: "amount1Min", type: "uint256" },
+            { name: "deadline", type: "uint256" }
+          ]
+        }
+      ],
+      outputs: [
+        { name: "amount0", type: "uint256" },
+        { name: "amount1", type: "uint256" }
+      ]
+    },
+    {
+      type: "function",
+      name: "collect",
+      stateMutability: "payable",
+      inputs: [
+        {
+          name: "params",
+          type: "tuple",
+          components: [
+            { name: "tokenId", type: "uint256" },
+            { name: "recipient", type: "address" },
+            { name: "amount0Max", type: "uint128" },
+            { name: "amount1Max", type: "uint128" }
+          ]
+        }
+      ],
+      outputs: [
+        { name: "amount0", type: "uint256" },
+        { name: "amount1", type: "uint256" }
+      ]
+    },
+    {
+      type: "function",
+      name: "permit",
+      stateMutability: "payable",
+      inputs: [
+        { name: "spender", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "v", type: "uint8" },
+        { name: "r", type: "bytes32" },
+        { name: "s", type: "bytes32" }
+      ],
+      outputs: []
+    },
+    { type: "function", name: "burn", stateMutability: "payable", inputs: [{ name: "tokenId", type: "uint256" }], outputs: [] },
+    {
+      type: "function",
+      name: "safeTransferFrom",
+      stateMutability: "payable",
+      inputs: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "tokenId", type: "uint256" }
+      ],
+      outputs: []
+    },
+    {
+      type: "function",
+      name: "safeTransferFrom",
+      stateMutability: "payable",
+      inputs: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "data", type: "bytes" }
+      ],
+      outputs: []
+    }
+  ]
+};
+
+// src/selfPermit.ts
+import { Interface as Interface2 } from "@ethersproject/abi";
+
+// src/abi/v3-periphery/ISelfPermit.json
+var ISelfPermit_default = {
+  abi: [
+    {
+      type: "function",
+      name: "selfPermit",
+      stateMutability: "payable",
+      inputs: [
+        { name: "token", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "v", type: "uint8" },
+        { name: "r", type: "bytes32" },
+        { name: "s", type: "bytes32" }
+      ],
+      outputs: []
+    },
+    {
+      type: "function",
+      name: "selfPermitAllowed",
+      stateMutability: "payable",
+      inputs: [
+        { name: "token", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "expiry", type: "uint256" },
+        { name: "v", type: "uint8" },
+        { name: "r", type: "bytes32" },
+        { name: "s", type: "bytes32" }
+      ],
+      outputs: []
+    }
+  ]
+};
+
+// src/selfPermit.ts
+function isAllowedPermit(permitOptions) {
+  return "nonce" in permitOptions;
+}
+var SelfPermit = class _SelfPermit {
+  static INTERFACE = new Interface2(ISelfPermit_default.abi);
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static encodePermit(token, options) {
+    return isAllowedPermit(options) ? _SelfPermit.INTERFACE.encodeFunctionData("selfPermitAllowed", [
+      token.address,
+      toHex(options.nonce),
+      toHex(options.expiry),
+      options.v,
+      options.r,
+      options.s
+    ]) : _SelfPermit.INTERFACE.encodeFunctionData("selfPermit", [
+      token.address,
+      toHex(options.amount),
+      toHex(options.deadline),
+      options.v,
+      options.r,
+      options.s
+    ]);
+  }
+};
+
+// src/payments.ts
+import { Interface as Interface3 } from "@ethersproject/abi";
+
+// src/abi/v3-periphery/IPeripheryPaymentsWithFee.json
+var IPeripheryPaymentsWithFee_default = {
+  abi: [
+    {
+      type: "function",
+      name: "unwrapWETH9",
+      stateMutability: "payable",
+      inputs: [
+        { name: "amountMinimum", type: "uint256" },
+        { name: "recipient", type: "address" }
+      ],
+      outputs: []
+    },
+    {
+      type: "function",
+      name: "unwrapWETH9WithFee",
+      stateMutability: "payable",
+      inputs: [
+        { name: "amountMinimum", type: "uint256" },
+        { name: "recipient", type: "address" },
+        { name: "feeBips", type: "uint256" },
+        { name: "feeRecipient", type: "address" }
+      ],
+      outputs: []
+    },
+    {
+      type: "function",
+      name: "sweepToken",
+      stateMutability: "payable",
+      inputs: [
+        { name: "token", type: "address" },
+        { name: "amountMinimum", type: "uint256" },
+        { name: "recipient", type: "address" }
+      ],
+      outputs: []
+    },
+    {
+      type: "function",
+      name: "sweepTokenWithFee",
+      stateMutability: "payable",
+      inputs: [
+        { name: "token", type: "address" },
+        { name: "amountMinimum", type: "uint256" },
+        { name: "recipient", type: "address" },
+        { name: "feeBips", type: "uint256" },
+        { name: "feeRecipient", type: "address" }
+      ],
+      outputs: []
+    },
+    {
+      type: "function",
+      name: "refundETH",
+      stateMutability: "payable",
+      inputs: [],
+      outputs: []
+    }
+  ]
+};
+
+// src/payments.ts
+import { validateAndParseAddress } from "@sun-protocol/sun-sdk-core";
+var Payments = class _Payments {
+  static INTERFACE = new Interface3(IPeripheryPaymentsWithFee_default.abi);
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static encodeFeeBips(fee) {
+    return toHex(fee.multiply(1e4).quotient);
+  }
+  static encodeUnwrapWETH9(amountMinimum, recipient, feeOptions) {
+    recipient = validateAndParseAddress(recipient);
+    if (feeOptions) {
+      const feeBips = this.encodeFeeBips(feeOptions.fee);
+      const feeRecipient = validateAndParseAddress(feeOptions.recipient);
+      return _Payments.INTERFACE.encodeFunctionData("unwrapWETH9WithFee", [
+        toHex(amountMinimum),
+        recipient,
+        feeBips,
+        feeRecipient
+      ]);
+    } else {
+      return _Payments.INTERFACE.encodeFunctionData("unwrapWETH9", [toHex(amountMinimum), recipient]);
+    }
+  }
+  static encodeSweepToken(token, amountMinimum, recipient, feeOptions) {
+    recipient = validateAndParseAddress(recipient);
+    if (feeOptions) {
+      const feeBips = this.encodeFeeBips(feeOptions.fee);
+      const feeRecipient = validateAndParseAddress(feeOptions.recipient);
+      return _Payments.INTERFACE.encodeFunctionData("sweepTokenWithFee", [
+        token.address,
+        toHex(amountMinimum),
+        recipient,
+        feeBips,
+        feeRecipient
+      ]);
+    } else {
+      return _Payments.INTERFACE.encodeFunctionData("sweepToken", [token.address, toHex(amountMinimum), recipient]);
+    }
+  }
+  static encodeRefundETH() {
+    return _Payments.INTERFACE.encodeFunctionData("refundETH");
+  }
+};
+
+// src/nonfungiblePositionManager.ts
+var MaxUint1282 = toHex(JSBI19.subtract(JSBI19.exponentiate(JSBI19.BigInt(2), JSBI19.BigInt(128)), JSBI19.BigInt(1)));
+function isMint(options) {
+  return Object.keys(options).some((k) => k === "recipient");
+}
+var NonfungiblePositionManager = class _NonfungiblePositionManager {
+  static INTERFACE = new Interface4(NonfungiblePositionManager_default.abi);
+  /**
+   * Cannot be constructed.
+   */
+  constructor() {
+  }
+  static encodeCreate(pool) {
+    return _NonfungiblePositionManager.INTERFACE.encodeFunctionData("createAndInitializePoolIfNecessary", [
+      pool.token0.address,
+      pool.token1.address,
+      pool.fee,
+      toHex(pool.sqrtRatioX96)
+    ]);
+  }
+  static createCallParameters(pool) {
+    return {
+      calldata: this.encodeCreate(pool),
+      function_selector: "createAndInitializePoolIfNecessary(address,address,uint24,uint160)",
+      parameter: [
+        { type: "address", value: pool.token0.address },
+        { type: "address", value: pool.token1.address },
+        { type: "uint24", value: pool.fee },
+        { type: "uint160", value: pool.sqrtRatioX96 }
+      ],
+      value: toHex(0)
+    };
+  }
+  static addCallParameters(position, options) {
+    invariant11(JSBI19.greaterThan(position.liquidity, ZERO), "ZERO_LIQUIDITY");
+    const calldatas = [];
+    const { amount0: amount0Desired, amount1: amount1Desired } = position.mintAmounts;
+    const minimumAmounts = position.mintAmountsWithSlippage(options.slippageTolerance);
+    const amount0Min = toHex(minimumAmounts.amount0);
+    const amount1Min = toHex(minimumAmounts.amount1);
+    const deadline = toHex(options.deadline);
+    if (isMint(options) && options.createPool) {
+      calldatas.push(this.encodeCreate(position.pool));
+    }
+    if (options.token0Permit) {
+      calldatas.push(SelfPermit.encodePermit(position.pool.token0, options.token0Permit));
+    }
+    if (options.token1Permit) {
+      calldatas.push(SelfPermit.encodePermit(position.pool.token1, options.token1Permit));
+    }
+    if (isMint(options)) {
+      const recipient = validateAndParseAddress2(options.recipient);
+      calldatas.push(
+        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("mint", [
+          {
+            token0: position.pool.token0.address,
+            token1: position.pool.token1.address,
+            fee: position.pool.fee,
+            tickLower: position.tickLower,
+            tickUpper: position.tickUpper,
+            amount0Desired: toHex(amount0Desired),
+            amount1Desired: toHex(amount1Desired),
+            amount0Min,
+            amount1Min,
+            recipient,
+            deadline
+          }
+        ])
+      );
+    } else {
+      calldatas.push(
+        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("increaseLiquidity", [
+          {
+            tokenId: toHex(options.tokenId),
+            amount0Desired: toHex(amount0Desired),
+            amount1Desired: toHex(amount1Desired),
+            amount0Min,
+            amount1Min,
+            deadline
+          }
+        ])
+      );
+    }
+    let value = toHex(0);
+    if (options.useNative) {
+      const wrapped = options.useNative.wrapped;
+      invariant11(position.pool.token0.equals(wrapped) || position.pool.token1.equals(wrapped), "NO_WETH");
+      const wrappedValue = position.pool.token0.equals(wrapped) ? amount0Desired : amount1Desired;
+      if (JSBI19.greaterThan(wrappedValue, ZERO)) {
+        calldatas.push(Payments.encodeRefundETH());
+      }
+      value = toHex(wrappedValue);
+    }
+    const parameter = [];
+    parameter.push({
+      type: "bytes[]",
+      value: calldatas
+    });
+    return {
+      calldata: Multicall.encodeMulticall(calldatas),
+      function_selector: "multicall(bytes[])",
+      parameter,
+      value
+    };
+  }
+  static encodeCollect(options) {
+    const calldatas = [];
+    const tokenId = toHex(options.tokenId);
+    const involvesETH = options.expectedCurrencyOwed0.currency.isNative || options.expectedCurrencyOwed1.currency.isNative;
+    const recipient = validateAndParseAddress2(options.recipient);
+    calldatas.push(
+      _NonfungiblePositionManager.INTERFACE.encodeFunctionData("collect", [
+        {
+          tokenId,
+          recipient: involvesETH ? ADDRESS_ZERO : recipient,
+          amount0Max: MaxUint1282,
+          amount1Max: MaxUint1282
+        }
+      ])
+    );
+    if (involvesETH) {
+      const ethAmount = options.expectedCurrencyOwed0.currency.isNative ? options.expectedCurrencyOwed0.quotient : options.expectedCurrencyOwed1.quotient;
+      const token = options.expectedCurrencyOwed0.currency.isNative ? options.expectedCurrencyOwed1.currency : options.expectedCurrencyOwed0.currency;
+      const tokenAmount = options.expectedCurrencyOwed0.currency.isNative ? options.expectedCurrencyOwed1.quotient : options.expectedCurrencyOwed0.quotient;
+      calldatas.push(Payments.encodeUnwrapWETH9(ethAmount, recipient));
+      calldatas.push(Payments.encodeSweepToken(token, tokenAmount, recipient));
+    }
+    return calldatas;
+  }
+  static collectCallParameters(options) {
+    const calldatas = _NonfungiblePositionManager.encodeCollect(options);
+    const parameter = [];
+    parameter.push({
+      type: "bytes[]",
+      value: calldatas
+    });
+    return {
+      calldata: Multicall.encodeMulticall(calldatas),
+      function_selector: "multicall(bytes[])",
+      parameter,
+      value: toHex(0)
+    };
+  }
+  /**
+   * Produces the calldata for completely or partially exiting a position
+   * @param position The position to exit
+   * @param options Additional information necessary for generating the calldata
+   * @returns The call parameters
+   */
+  static removeCallParameters(position, options) {
+    const calldatas = [];
+    const deadline = toHex(options.deadline);
+    const tokenId = toHex(options.tokenId);
+    const partialPosition = new Position({
+      pool: position.pool,
+      liquidity: options.liquidityPercentage.multiply(position.liquidity).quotient,
+      tickLower: position.tickLower,
+      tickUpper: position.tickUpper
+    });
+    invariant11(JSBI19.greaterThan(partialPosition.liquidity, ZERO), "ZERO_LIQUIDITY");
+    const { amount0: amount0Min, amount1: amount1Min } = partialPosition.burnAmountsWithSlippage(
+      options.slippageTolerance
+    );
+    if (options.permit) {
+      calldatas.push(
+        _NonfungiblePositionManager.INTERFACE.encodeFunctionData("permit", [
+          validateAndParseAddress2(options.permit.spender),
+          tokenId,
+          toHex(options.permit.deadline),
+          options.permit.v,
+          options.permit.r,
+          options.permit.s
+        ])
+      );
+    }
+    calldatas.push(
+      _NonfungiblePositionManager.INTERFACE.encodeFunctionData("decreaseLiquidity", [
+        {
+          tokenId,
+          liquidity: toHex(partialPosition.liquidity),
+          amount0Min: toHex(amount0Min),
+          amount1Min: toHex(amount1Min),
+          deadline
+        }
+      ])
+    );
+    const { expectedCurrencyOwed0, expectedCurrencyOwed1, ...rest } = options.collectOptions;
+    calldatas.push(
+      ..._NonfungiblePositionManager.encodeCollect({
+        tokenId: toHex(options.tokenId),
+        // add the underlying value to the expected currency already owed
+        expectedCurrencyOwed0: expectedCurrencyOwed0.add(
+          CurrencyAmount4.fromRawAmount(expectedCurrencyOwed0.currency, amount0Min)
+        ),
+        expectedCurrencyOwed1: expectedCurrencyOwed1.add(
+          CurrencyAmount4.fromRawAmount(expectedCurrencyOwed1.currency, amount1Min)
+        ),
+        ...rest
+      })
+    );
+    if (options.liquidityPercentage.equalTo(ONE)) {
+      if (options.burnToken) {
+        calldatas.push(_NonfungiblePositionManager.INTERFACE.encodeFunctionData("burn", [tokenId]));
+      }
+    } else {
+      invariant11(options.burnToken !== true, "CANNOT_BURN");
+    }
+    const parameter = [];
+    parameter.push({
+      type: "bytes[]",
+      value: calldatas
+    });
+    return {
+      calldata: Multicall.encodeMulticall(calldatas),
+      function_selector: "multicall(bytes[])",
+      parameter,
+      value: toHex(0)
+    };
+  }
+  static safeTransferFromParameters(options) {
+    const recipient = validateAndParseAddress2(options.recipient);
+    const sender = validateAndParseAddress2(options.sender);
+    let calldata;
+    let function_selector;
+    let parameter;
+    if (options.data) {
+      calldata = _NonfungiblePositionManager.INTERFACE.encodeFunctionData(
+        "safeTransferFrom(address,address,uint256,bytes)",
+        [sender, recipient, toHex(options.tokenId), options.data]
+      );
+      function_selector = "safeTransferFrom(address,address,uint256,bytes)";
+      parameter = [
+        { type: "address", value: sender },
+        { type: "address", value: recipient },
+        { type: "uint256", value: options.tokenId },
+        { type: "bytes", value: options.data }
+      ];
+    } else {
+      calldata = _NonfungiblePositionManager.INTERFACE.encodeFunctionData("safeTransferFrom(address,address,uint256)", [
+        sender,
+        recipient,
+        toHex(options.tokenId)
+      ]);
+      function_selector = "safeTransferFrom(address,address,uint256)";
+      parameter = [
+        { type: "address", value: sender },
+        { type: "address", value: recipient },
+        { type: "uint256", value: options.tokenId }
+      ];
+    }
+    return {
+      calldata,
+      function_selector,
+      parameter,
+      value: toHex(0)
+    };
+  }
+};
+
+// src/pool-address.ts
+import { getContractAddress as getContractAddress2, getWrappedNativeAddress } from "@sun-protocol/sun-sdk-chains";
+import { keccak256 as keccak2563 } from "@ethersproject/keccak256";
+import { sha256 } from "@noble/hashes/sha256";
+import { SDK_ERROR_CODES as SDK_ERROR_CODES2, sdkInvariant as sdkInvariant2 } from "@sun-protocol/sun-sdk-core";
+var V3_INIT_CODE_HASH = {
+  mainnet: "0xba928a717d71946d75999ef1adef801a79cd34a20efecea8b2876b85f5f49580",
+  nile: "0xbdafe9a36668104a2d371dedf31aac9583722f1b2c2fe98dde229f50a1e81689"
+};
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE58_ZERO = "1";
+var HEX_20_BYTES_PATTERN = /^0x[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";
+var TRON_ZERO_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+function decodeBase58(value) {
+  let decoded = 0n;
+  for (const char of value) {
+    const index = BASE58_ALPHABET.indexOf(char);
+    sdkInvariant2(index >= 0, SDK_ERROR_CODES2.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 !== BASE58_ZERO) 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];
+    sdkInvariant2(char !== void 0, SDK_ERROR_CODES2.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;
+  sdkInvariant2(/^[a-fA-F0-9]*$/.test(normalized) && normalized.length % 2 === 0, SDK_ERROR_CODES2.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 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) {
+  if (HEX_20_BYTES_PATTERN.test(address)) return address.slice(2).toLowerCase();
+  const decoded = decodeBase58(address);
+  sdkInvariant2(
+    decoded.length === TRON_ADDRESS_PAYLOAD_BYTES,
+    SDK_ERROR_CODES2.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);
+  sdkInvariant2(
+    bytesToHex(expectedChecksum) === bytesToHex(actualChecksum),
+    SDK_ERROR_CODES2.SDK_INVALID_ARGUMENT,
+    `${label} has invalid TRON base58 checksum`,
+    { label, value: address }
+  );
+  sdkInvariant2(body[0] === 65, SDK_ERROR_CODES2.SDK_INVALID_ARGUMENT, `${label} must use TRON 0x41 prefix`, {
+    label,
+    value: address
+  });
+  return bytesToHex(body.slice(1));
+}
+function normalizeV3InitCodeHash(value) {
+  sdkInvariant2(HEX_32_BYTES_PATTERN.test(value), SDK_ERROR_CODES2.SDK_INVALID_ARGUMENT, "V3 initCodeHash must be bytes32 hex", {
+    value
+  });
+  return value.startsWith("0x") ? value.slice(2).toLowerCase() : value.toLowerCase();
+}
+function normalizeV3TokenAddress(token, wrappedNative, label) {
+  const address = typeof token === "string" ? token : token.address;
+  const normalized = address === TRON_ZERO_ADDRESS ? wrappedNative : address;
+  return tronAddressToEvmHex(normalized, label);
+}
+function encodeV3PoolSalt(token0, token1, fee) {
+  sdkInvariant2(Number.isInteger(fee) && fee >= 0 && fee <= 16777215, SDK_ERROR_CODES2.SDK_INVALID_ARGUMENT, "V3 fee must be uint24", {
+    fee
+  });
+  return `${token0.padStart(64, "0")}${token1.padStart(64, "0")}${fee.toString(16).padStart(64, "0")}`;
+}
+function computeV3PoolAddress(params) {
+  const wrappedNative = params.wrappedNative ?? getWrappedNativeAddress(params.network);
+  const tokenA = normalizeV3TokenAddress(params.tokenA, wrappedNative, "tokenA");
+  const tokenB = normalizeV3TokenAddress(params.tokenB, wrappedNative, "tokenB");
+  sdkInvariant2(tokenA !== tokenB, SDK_ERROR_CODES2.SDK_INVALID_ARGUMENT, "V3 pool tokens must be different", {
+    tokenA: typeof params.tokenA === "string" ? params.tokenA : params.tokenA.address,
+    tokenB: typeof params.tokenB === "string" ? params.tokenB : params.tokenB.address
+  });
+  const [token0, token1] = tokenA < tokenB ? [tokenA, tokenB] : [tokenB, tokenA];
+  const factory = tronAddressToEvmHex(params.factory ?? getContractAddress2(params.network, "sunswapV3Factory"), "factory");
+  const salt = keccak2563(hexToBytes(encodeV3PoolSalt(token0, token1, params.fee), "pool salt")).slice(2);
+  const initCodeHash = normalizeV3InitCodeHash(params.initCodeHash ?? V3_INIT_CODE_HASH[params.network]);
+  const hash = keccak2563(hexToBytes(`${TRON_PREFIX_HEX}${factory}${salt}${initCodeHash}`, "CREATE2 input")).slice(2);
+  return tronPayloadToBase58(hexToBytes(`${TRON_PREFIX_HEX}${hash.slice(-40)}`, "pool address"));
+}
+
+// src/reads.ts
+import { getContractAddress as getContractAddress3 } from "@sun-protocol/sun-sdk-chains";
+import JSBI20 from "jsbi";
+var V3_POOL_READ_SELECTORS = {
+  slot0: "slot0()",
+  liquidity: "liquidity()",
+  fee: "fee()",
+  tickSpacing: "tickSpacing()"
+};
+var V3_POSITION_MANAGER_READ_SELECTORS = {
+  positions: "positions(uint256)",
+  ownerOf: "ownerOf(uint256)",
+  getApproved: "getApproved(uint256)",
+  isApprovedForAll: "isApprovedForAll(address,address)"
+};
+function valueOf2(value) {
+  return JSBI20.BigInt(value).toString();
+}
+function positionManagerTarget2(params) {
+  return params.positionManager ?? getContractAddress3(params.network, "sunswapV3PositionManager");
+}
+function poolRead(pool, functionSelector, abiFunction) {
+  return {
+    target: pool,
+    functionSelector,
+    abiFunction,
+    metadata: { protocol: "sunswap-v3", contract: "pool" }
+  };
+}
+function positionManagerRead(params, functionSelector, parameters, abiFunction, action) {
+  return {
+    target: positionManagerTarget2(params),
+    functionSelector,
+    parameters,
+    abiFunction,
+    metadata: { protocol: "sunswap-v3", contract: "position-manager", action, network: params.network }
+  };
+}
+function buildV3PoolSlot0Read(params) {
+  return poolRead(params.pool, V3_POOL_READ_SELECTORS.slot0, V3_POOL_SLOT0_ABI);
+}
+function buildV3PoolLiquidityRead(params) {
+  return poolRead(params.pool, V3_POOL_READ_SELECTORS.liquidity, V3_POOL_LIQUIDITY_ABI);
+}
+function buildV3PoolFeeRead(params) {
+  return poolRead(params.pool, V3_POOL_READ_SELECTORS.fee, V3_POOL_FEE_ABI);
+}
+function buildV3PoolTickSpacingRead(params) {
+  return poolRead(params.pool, V3_POOL_READ_SELECTORS.tickSpacing, V3_POOL_TICK_SPACING_ABI);
+}
+function buildV3PoolStateReads(params) {
+  return [
+    buildV3PoolSlot0Read(params),
+    buildV3PoolLiquidityRead(params),
+    buildV3PoolFeeRead(params),
+    buildV3PoolTickSpacingRead(params)
+  ];
+}
+function buildV3PositionRead(params) {
+  return positionManagerRead(
+    params,
+    V3_POSITION_MANAGER_READ_SELECTORS.positions,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    V3_POSITION_MANAGER_POSITIONS_ABI,
+    "positions"
+  );
+}
+function buildV3PositionOwnerRead(params) {
+  return positionManagerRead(
+    params,
+    V3_POSITION_MANAGER_READ_SELECTORS.ownerOf,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    V3_POSITION_MANAGER_OWNER_OF_ABI,
+    "owner-of"
+  );
+}
+function buildV3PositionApprovedRead(params) {
+  return positionManagerRead(
+    params,
+    V3_POSITION_MANAGER_READ_SELECTORS.getApproved,
+    [{ type: "uint256", value: valueOf2(params.tokenId) }],
+    V3_POSITION_MANAGER_GET_APPROVED_ABI,
+    "get-approved"
+  );
+}
+function buildV3PositionApprovalForAllRead(params) {
+  return positionManagerRead(
+    params,
+    V3_POSITION_MANAGER_READ_SELECTORS.isApprovedForAll,
+    [
+      { type: "address", value: params.owner },
+      { type: "address", value: params.operator }
+    ],
+    V3_POSITION_MANAGER_IS_APPROVED_FOR_ALL_ABI,
+    "is-approved-for-all"
+  );
+}
+function buildV3PositionReads(params) {
+  return [
+    buildV3PositionRead(params),
+    buildV3PositionOwnerRead(params),
+    buildV3PositionApprovedRead(params)
+  ];
+}
+export {
+  ADDRESS_ZERO,
+  FACTORY_ADDRESS,
+  FeeAmount,
+  FullMath,
+  IS_TVM,
+  LiquidityMath,
+  MaxUint128,
+  Multicall,
+  NoTickDataProvider,
+  NonfungiblePositionManager,
+  POOL_INIT_CODE_HASH,
+  Payments,
+  Pool,
+  Position,
+  PositionLibrary,
+  Route,
+  SelfPermit,
+  SqrtPriceMath,
+  SwapMath,
+  TICK_SPACINGS,
+  Tick,
+  TickLibrary,
+  TickList,
+  TickListDataProvider,
+  TickMath,
+  Trade,
+  V3_INIT_CODE_HASH,
+  V3_POOL_FEE_ABI,
+  V3_POOL_LIQUIDITY_ABI,
+  V3_POOL_READ_SELECTORS,
+  V3_POOL_SLOT0_ABI,
+  V3_POOL_TICK_SPACING_ABI,
+  V3_POSITION_MANAGER_GET_APPROVED_ABI,
+  V3_POSITION_MANAGER_IS_APPROVED_FOR_ALL_ABI,
+  V3_POSITION_MANAGER_OWNER_OF_ABI,
+  V3_POSITION_MANAGER_POSITIONS_ABI,
+  V3_POSITION_MANAGER_READ_SELECTORS,
+  V3_POSITION_MANAGER_SELECTORS,
+  buildV3CollectAction,
+  buildV3CreatePoolAction,
+  buildV3DecreaseLiquidityAction,
+  buildV3IncreaseLiquidityAction,
+  buildV3MintPositionAction,
+  buildV3PoolFeeRead,
+  buildV3PoolLiquidityRead,
+  buildV3PoolSlot0Read,
+  buildV3PoolStateReads,
+  buildV3PoolTickSpacingRead,
+  buildV3PositionApprovalForAllRead,
+  buildV3PositionApprovedRead,
+  buildV3PositionOwnerRead,
+  buildV3PositionRead,
+  buildV3PositionReads,
+  computePoolAddress,
+  computeV3PoolAddress,
+  encodeRouteToPath,
+  encodeSqrtRatioX96,
+  getTickSpacing,
+  getTronCreate2Address,
+  isSorted,
+  isSupportedFeeAmount,
+  maxLiquidityForAmounts,
+  mostSignificantBit,
+  nearestUsableTick,
+  priceToClosestTick,
+  subIn256,
+  tickToPrice,
+  toHex,
+  tradeComparator,
+  validateTickRange,
+  validateTickRangeForFee,
+  validateTickSpacing
+};
+//# sourceMappingURL=index.js.map