@skate-org/amm-evm-v2 0.4.1

package/dist/index.cjs

@@ -0,0 +1,997 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_DEV_API_ENDPOINT: () => DEFAULT_DEV_API_ENDPOINT,
+  EvmReadError: () => EvmReadError,
+  EvmWriteError: () => EvmWriteError,
+  KERNEL_EVENT_NAMES: () => KERNEL_EVENT_NAMES,
+  MAX_SQRT_RATIO: () => MAX_SQRT_RATIO,
+  MAX_TICK: () => MAX_TICK,
+  MIN_SQRT_RATIO: () => MIN_SQRT_RATIO,
+  MIN_TICK: () => MIN_TICK,
+  PERIPHERY_EVENT_NAMES: () => PERIPHERY_EVENT_NAMES,
+  addDelta: () => addDelta,
+  computePositionAmounts: () => computePositionAmounts,
+  createDevConfig: () => createDevConfig,
+  decodeTickBitmapWord: () => decodeTickBitmapWord,
+  getAmount0Delta: () => getAmount0Delta,
+  getAmount0DeltaSigned: () => getAmount0DeltaSigned,
+  getAmount1Delta: () => getAmount1Delta,
+  getAmount1DeltaSigned: () => getAmount1DeltaSigned,
+  getKernelPublicClient: () => getKernelPublicClient,
+  getNextSqrtPriceFromAmount0RoundingUp: () => getNextSqrtPriceFromAmount0RoundingUp,
+  getNextSqrtPriceFromAmount1RoundingDown: () => getNextSqrtPriceFromAmount1RoundingDown,
+  getNextSqrtPriceFromInput: () => getNextSqrtPriceFromInput,
+  getNextSqrtPriceFromOutput: () => getNextSqrtPriceFromOutput,
+  getSourcePublicClient: () => getSourcePublicClient,
+  getSqrtRatioAtTick: () => getSqrtRatioAtTick,
+  getTickAtSqrtRatio: () => getTickAtSqrtRatio,
+  megaethChain: () => megaethChain,
+  mulDiv: () => mulDiv,
+  mulDivRoundingUp: () => mulDivRoundingUp,
+  parseKernelEventLog: () => parseKernelEventLog,
+  parsePeripheryEventLog: () => parsePeripheryEventLog,
+  readPeripheryPool: () => readPeripheryPool,
+  readPool: () => readPool,
+  readPosition: () => readPosition,
+  readTick: () => readTick,
+  readTickBitmap: () => readTickBitmap,
+  readUserPoolBalances: () => readUserPoolBalances,
+  submitAction: () => submitAction,
+  submitApproval: () => submitApproval,
+  submitSwap: () => submitSwap,
+  watchKernelEvents: () => watchKernelEvents,
+  watchPeripheryEvents: () => watchPeripheryEvents
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/chain-clients.ts
+var import_viem = require("viem");
+var import_chains = require("viem/chains");
+var import_amm_core_v2 = require("@skate-org/amm-core-v2");
+var megaethChain = (0, import_viem.defineChain)({
+  id: 4326,
+  name: "MegaETH",
+  network: "megaeth",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://mainnet.megaeth.com/rpc"] },
+    public: { http: ["https://mainnet.megaeth.com/rpc"] }
+  },
+  blockExplorers: {
+    default: { name: "Blockscout", url: import_amm_core_v2.BLOCK_EXPLORER.MEGAETH }
+  }
+});
+var DEFAULT_RPC = {
+  [import_amm_core_v2.CHAIN.MEGAETH]: "https://mainnet.megaeth.com/rpc",
+  [import_amm_core_v2.CHAIN.ARBITRUM]: "https://arb1.arbitrum.io/rpc"
+};
+function chainDefFor(chain) {
+  switch (chain) {
+    case import_amm_core_v2.CHAIN.MEGAETH:
+      return megaethChain;
+    case import_amm_core_v2.CHAIN.ARBITRUM:
+      return import_chains.arbitrum;
+    default:
+      return void 0;
+  }
+}
+function resolveRpcUrl(chain, mode) {
+  const { config } = (0, import_amm_core_v2.normalizeMode)(mode);
+  return config?.rpcEndpoints?.[chain] ?? DEFAULT_RPC[chain];
+}
+function getKernelPublicClient(mode, transport) {
+  return (0, import_viem.createPublicClient)({
+    chain: megaethChain,
+    transport: transport ?? (0, import_viem.http)(resolveRpcUrl(import_amm_core_v2.CHAIN.MEGAETH, mode))
+  });
+}
+function getSourcePublicClient(chain, mode, transport) {
+  if ((0, import_amm_core_v2.vmTypeFromChain)(chain) !== import_amm_core_v2.VM.EVM) {
+    throw new Error(
+      `getSourcePublicClient: chain ${chain} is not an EVM chain`
+    );
+  }
+  const chainDef = chainDefFor(chain);
+  if (!chainDef) {
+    throw new Error(
+      `getSourcePublicClient: no chain definition registered for chain ${chain}`
+    );
+  }
+  const rpc = resolveRpcUrl(chain, mode);
+  if (!rpc && !transport) {
+    throw new Error(
+      `getSourcePublicClient: no default or override RPC configured for chain ${chain}; pass a transport override or set DevModeConfig.rpcEndpoints[${chain}]`
+    );
+  }
+  return (0, import_viem.createPublicClient)({
+    chain: chainDef,
+    transport: transport ?? (0, import_viem.http)(rpc)
+  });
+}
+
+// src/devConfig.ts
+var DEFAULT_DEV_API_ENDPOINT = "https://dev.api.skatechain.org/amm-action-v2";
+function createDevConfig(overrides = {}) {
+  return {
+    mode: "DEV",
+    config: {
+      apiEndpoint: overrides.apiEndpoint ?? DEFAULT_DEV_API_ENDPOINT,
+      ...overrides.rpcEndpoints ? { rpcEndpoints: overrides.rpcEndpoints } : {}
+    }
+  };
+}
+
+// src/errors.ts
+var import_amm_core_v22 = require("@skate-org/amm-core-v2");
+var EvmReadError = class extends import_amm_core_v22.SdkError {
+  name = "EvmReadError";
+  functionName;
+  constructor(functionName, message, options) {
+    super(`${functionName}: ${message}`, options);
+    this.functionName = functionName;
+  }
+};
+var EvmWriteError = class extends import_amm_core_v22.SdkError {
+  name = "EvmWriteError";
+  functionName;
+  constructor(functionName, message, options) {
+    super(`${functionName}: ${message}`, options);
+    this.functionName = functionName;
+  }
+};
+function wrapReadError(err, functionName) {
+  const outerName = err?.name;
+  const causeName = err?.cause?.name;
+  const message = err?.shortMessage ?? err?.message ?? String(err);
+  const isViemContractError = outerName === "ContractFunctionExecutionError" || outerName === "ContractFunctionRevertedError" || outerName === "ContractFunctionZeroDataError" || causeName === "ContractFunctionRevertedError" || causeName === "ContractFunctionZeroDataError";
+  if (isViemContractError) {
+    return new EvmReadError(functionName, `reverted: ${message}`, {
+      cause: err
+    });
+  }
+  return new EvmReadError(functionName, message, { cause: err });
+}
+function wrapWriteError(err, functionName) {
+  const message = err?.shortMessage ?? err?.message ?? String(err);
+  return new EvmWriteError(functionName, message, { cause: err });
+}
+
+// src/math/tickMath.ts
+var MAX_UINT256 = (1n << 256n) - 1n;
+var Q160_MASK = (1n << 160n) - 1n;
+var Q256_MOD = 1n << 256n;
+var MIN_TICK = -887272;
+var MAX_TICK = 887272;
+var MIN_SQRT_RATIO = 4295128739n;
+var MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
+function getSqrtRatioAtTick(tick) {
+  if (!Number.isInteger(tick)) {
+    throw new Error("TickMath: tick must be an integer");
+  }
+  const absTick = BigInt(tick < 0 ? -tick : tick);
+  if (absTick > BigInt(MAX_TICK)) {
+    throw new Error("T");
+  }
+  let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
+  if ((absTick & 0x2n) !== 0n)
+    ratio = (ratio * 0xfff97272373d413259a46990580e213an & MAX_UINT256) >> 128n;
+  if ((absTick & 0x4n) !== 0n)
+    ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdccn & MAX_UINT256) >> 128n;
+  if ((absTick & 0x8n) !== 0n)
+    ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x10n) !== 0n)
+    ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x20n) !== 0n)
+    ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x40n) !== 0n)
+    ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x80n) !== 0n)
+    ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x100n) !== 0n)
+    ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x200n) !== 0n)
+    ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x400n) !== 0n)
+    ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x800n) !== 0n)
+    ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x1000n) !== 0n)
+    ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x2000n) !== 0n)
+    ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x4000n) !== 0n)
+    ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x8000n) !== 0n)
+    ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x10000n) !== 0n)
+    ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x20000n) !== 0n)
+    ratio = (ratio * 0x5d6af8dedb81196699c329225ee604n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x40000n) !== 0n)
+    ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98n & MAX_UINT256) >> 128n;
+  if ((absTick & 0x80000n) !== 0n)
+    ratio = (ratio * 0x48a170391f7dc42444e8fa2n & MAX_UINT256) >> 128n;
+  if (tick > 0) ratio = MAX_UINT256 / ratio;
+  const shifted = ratio >> 32n;
+  const remainder = ratio & (1n << 32n) - 1n;
+  const sqrtPriceX96 = remainder === 0n ? shifted : shifted + 1n;
+  return sqrtPriceX96 & Q160_MASK;
+}
+function getTickAtSqrtRatio(sqrtPriceX96) {
+  if (sqrtPriceX96 < MIN_SQRT_RATIO || sqrtPriceX96 >= MAX_SQRT_RATIO) {
+    throw new Error("R");
+  }
+  const ratio = sqrtPriceX96 << 32n;
+  let r = ratio;
+  let msb = 0n;
+  {
+    const f = r > 0xffffffffffffffffffffffffffffffffn ? 128n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0xffffffffffffffffn ? 64n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0xffffffffn ? 32n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0xffffn ? 16n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0xffn ? 8n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0xfn ? 4n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0x3n ? 2n : 0n;
+    msb |= f;
+    r >>= f;
+  }
+  {
+    const f = r > 0x1n ? 1n : 0n;
+    msb |= f;
+  }
+  if (msb >= 128n) r = ratio >> msb - 127n;
+  else r = ratio << 127n - msb & MAX_UINT256;
+  const offset = msb - 128n;
+  let log_2 = offset << 64n & MAX_UINT256;
+  for (let i = 0; i < 14; i++) {
+    r = r * r >> 127n;
+    const f = r >> 128n;
+    log_2 |= f << BigInt(63 - i);
+    r >>= f;
+  }
+  const log_2_signed = toInt256(log_2);
+  const log_sqrt10001 = log_2_signed * 255738958999603826347141n;
+  const tickLowBig = log_sqrt10001 - 3402992956809132418596140100660247210n >> 128n;
+  const tickHiBig = log_sqrt10001 + 291339464771989622907027621153398088495n >> 128n;
+  const tickLow = toInt24(tickLowBig);
+  const tickHi = toInt24(tickHiBig);
+  if (tickLow === tickHi) return tickLow;
+  return getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
+}
+function toInt256(x) {
+  const masked = x & MAX_UINT256;
+  return masked >= 1n << 255n ? masked - Q256_MOD : masked;
+}
+function toInt24(x) {
+  const mask = (1n << 24n) - 1n;
+  const truncated = x & mask;
+  const signed = truncated >= 1n << 23n ? truncated - (1n << 24n) : truncated;
+  return Number(signed);
+}
+
+// src/math/fullMath.ts
+var MAX_UINT2562 = (1n << 256n) - 1n;
+function mulDiv(a, b, denom) {
+  if (denom === 0n) {
+    throw new Error("FullMath: division by zero");
+  }
+  if (a < 0n || b < 0n || denom < 0n) {
+    throw new Error("FullMath: negative input");
+  }
+  const product = a * b;
+  const result = product / denom;
+  if (result > MAX_UINT2562) {
+    throw new Error("FullMath: result overflows uint256");
+  }
+  return result;
+}
+function mulDivRoundingUp(a, b, denom) {
+  if (denom === 0n) {
+    throw new Error("FullMath: division by zero");
+  }
+  if (a < 0n || b < 0n || denom < 0n) {
+    throw new Error("FullMath: negative input");
+  }
+  const product = a * b;
+  const quotient = product / denom;
+  if (quotient > MAX_UINT2562) {
+    throw new Error("FullMath: result overflows uint256");
+  }
+  if (product % denom !== 0n) {
+    if (quotient === MAX_UINT2562) {
+      throw new Error("FullMath: rounding up overflows uint256");
+    }
+    return quotient + 1n;
+  }
+  return quotient;
+}
+
+// src/math/sqrtPriceMath.ts
+var MAX_UINT128 = (1n << 128n) - 1n;
+var MAX_UINT160 = (1n << 160n) - 1n;
+var MAX_UINT2563 = (1n << 256n) - 1n;
+var Q96_RESOLUTION = 96n;
+var Q96 = 1n << 96n;
+function assertUint160(x, name) {
+  if (x < 0n || x > MAX_UINT160) {
+    throw new Error(`SqrtPriceMath: ${name} out of uint160 range`);
+  }
+}
+function assertUint128(x, name) {
+  if (x < 0n || x > MAX_UINT128) {
+    throw new Error(`SqrtPriceMath: ${name} out of uint128 range`);
+  }
+}
+function assertUint256(x, name) {
+  if (x < 0n || x > MAX_UINT2563) {
+    throw new Error(`SqrtPriceMath: ${name} out of uint256 range`);
+  }
+}
+function divRoundingUp(x, y) {
+  if (y === 0n) throw new Error("SqrtPriceMath: div by zero");
+  return x / y + (x % y === 0n ? 0n : 1n);
+}
+function toUint160(x) {
+  if (x > MAX_UINT160) throw new Error("SqrtPriceMath: toUint160 overflow");
+  return x;
+}
+function getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add) {
+  assertUint160(sqrtPX96, "sqrtPX96");
+  assertUint128(liquidity, "liquidity");
+  assertUint256(amount, "amount");
+  if (amount === 0n) return sqrtPX96;
+  const numerator1 = liquidity << Q96_RESOLUTION;
+  if (add) {
+    const product = amount * sqrtPX96 & MAX_UINT2563;
+    const noOverflow = amount === 0n || product / amount === sqrtPX96;
+    if (noOverflow) {
+      const denominator = numerator1 + product;
+      if (denominator >= numerator1) {
+        return toUint160(mulDivRoundingUp(numerator1, sqrtPX96, denominator));
+      }
+    }
+    if (sqrtPX96 === 0n) throw new Error("SqrtPriceMath: sqrtPX96 == 0");
+    const denom = numerator1 / sqrtPX96 + amount;
+    return toUint160(divRoundingUp(numerator1, denom));
+  } else {
+    const product = amount * sqrtPX96 & MAX_UINT2563;
+    const noOverflow = amount === 0n || product / amount === sqrtPX96;
+    if (!noOverflow || numerator1 <= product) {
+      throw new Error("SqrtPriceMath: getNextSqrtPriceFromAmount0 denom <= 0");
+    }
+    const denominator = numerator1 - product;
+    return toUint160(mulDivRoundingUp(numerator1, sqrtPX96, denominator));
+  }
+}
+function getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add) {
+  assertUint160(sqrtPX96, "sqrtPX96");
+  assertUint128(liquidity, "liquidity");
+  assertUint256(amount, "amount");
+  if (add) {
+    const quotient = amount <= MAX_UINT160 ? (amount << Q96_RESOLUTION) / liquidity : mulDiv(amount, Q96, liquidity);
+    return toUint160(sqrtPX96 + quotient);
+  } else {
+    const quotient = amount <= MAX_UINT160 ? divRoundingUp(amount << Q96_RESOLUTION, liquidity) : mulDivRoundingUp(amount, Q96, liquidity);
+    if (sqrtPX96 <= quotient) {
+      throw new Error("SqrtPriceMath: sqrtPX96 <= quotient");
+    }
+    return sqrtPX96 - quotient;
+  }
+}
+function getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
+  if (sqrtPX96 <= 0n) throw new Error("SqrtPriceMath: sqrtPX96 must be > 0");
+  if (liquidity <= 0n)
+    throw new Error("SqrtPriceMath: liquidity must be > 0");
+  return zeroForOne ? getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true) : getNextSqrtPriceFromAmount1RoundingDown(
+    sqrtPX96,
+    liquidity,
+    amountIn,
+    true
+  );
+}
+function getNextSqrtPriceFromOutput(sqrtPX96, liquidity, amountOut, zeroForOne) {
+  if (sqrtPX96 <= 0n) throw new Error("SqrtPriceMath: sqrtPX96 must be > 0");
+  if (liquidity <= 0n)
+    throw new Error("SqrtPriceMath: liquidity must be > 0");
+  return zeroForOne ? getNextSqrtPriceFromAmount1RoundingDown(
+    sqrtPX96,
+    liquidity,
+    amountOut,
+    false
+  ) : getNextSqrtPriceFromAmount0RoundingUp(
+    sqrtPX96,
+    liquidity,
+    amountOut,
+    false
+  );
+}
+function getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
+  assertUint160(sqrtRatioAX96, "sqrtRatioAX96");
+  assertUint160(sqrtRatioBX96, "sqrtRatioBX96");
+  assertUint128(liquidity, "liquidity");
+  let a = sqrtRatioAX96;
+  let b = sqrtRatioBX96;
+  if (a > b) {
+    [a, b] = [b, a];
+  }
+  if (a === 0n) throw new Error("SqrtPriceMath: sqrtRatio must be > 0");
+  const numerator1 = liquidity << Q96_RESOLUTION;
+  const numerator2 = b - a;
+  if (roundUp) {
+    return divRoundingUp(mulDivRoundingUp(numerator1, numerator2, b), a);
+  }
+  return mulDiv(numerator1, numerator2, b) / a;
+}
+function getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
+  assertUint160(sqrtRatioAX96, "sqrtRatioAX96");
+  assertUint160(sqrtRatioBX96, "sqrtRatioBX96");
+  assertUint128(liquidity, "liquidity");
+  let a = sqrtRatioAX96;
+  let b = sqrtRatioBX96;
+  if (a > b) {
+    [a, b] = [b, a];
+  }
+  return roundUp ? mulDivRoundingUp(liquidity, b - a, Q96) : mulDiv(liquidity, b - a, Q96);
+}
+function getAmount0DeltaSigned(sqrtRatioAX96, sqrtRatioBX96, liquidity) {
+  const INT128_MIN2 = -(1n << 127n);
+  const INT128_MAX2 = (1n << 127n) - 1n;
+  if (liquidity < INT128_MIN2 || liquidity > INT128_MAX2) {
+    throw new Error("SqrtPriceMath: liquidity out of int128 range");
+  }
+  if (liquidity < 0n) {
+    return -getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, -liquidity, false);
+  }
+  return getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, true);
+}
+function getAmount1DeltaSigned(sqrtRatioAX96, sqrtRatioBX96, liquidity) {
+  const INT128_MIN2 = -(1n << 127n);
+  const INT128_MAX2 = (1n << 127n) - 1n;
+  if (liquidity < INT128_MIN2 || liquidity > INT128_MAX2) {
+    throw new Error("SqrtPriceMath: liquidity out of int128 range");
+  }
+  if (liquidity < 0n) {
+    return -getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, -liquidity, false);
+  }
+  return getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, true);
+}
+
+// src/math/liquidityMath.ts
+var MAX_UINT1282 = (1n << 128n) - 1n;
+var INT128_MAX = (1n << 127n) - 1n;
+var INT128_MIN = -(1n << 127n);
+function addDelta(x, y) {
+  if (x < 0n || x > MAX_UINT1282) {
+    throw new Error("LiquidityMath: x out of uint128 range");
+  }
+  if (y < INT128_MIN || y > INT128_MAX) {
+    throw new Error("LiquidityMath: y out of int128 range");
+  }
+  const z = x + y;
+  if (y < 0n) {
+    if (z < 0n) throw new Error("LS");
+  } else {
+    if (z > MAX_UINT1282) throw new Error("LA");
+  }
+  return z;
+}
+
+// src/kernel/reader.ts
+var import_amm_bindings = require("@skate-org/amm-bindings");
+var import_amm_core_v23 = require("@skate-org/amm-core-v2");
+function resolveClient(mode, client) {
+  return client ?? getKernelPublicClient(mode);
+}
+async function readPool(kernelPool, mode, client) {
+  const c = resolveClient(mode, client);
+  try {
+    const [slot0, liquidity] = await Promise.all([
+      c.readContract({
+        address: kernelPool,
+        abi: import_amm_bindings.KernelPoolABI,
+        functionName: "slot0"
+      }),
+      c.readContract({
+        address: kernelPool,
+        abi: import_amm_bindings.KernelPoolABI,
+        functionName: "liquidity"
+      })
+    ]);
+    const s0 = slot0;
+    return {
+      slot0: {
+        sqrtPriceX96: s0[0],
+        tick: s0[1],
+        observationIndex: s0[2],
+        observationCardinality: s0[3],
+        observationCardinalityNext: s0[4],
+        feeProtocol: s0[5],
+        unlocked: s0[6]
+      },
+      liquidity
+    };
+  } catch (err) {
+    throw wrapReadError(err, "readPool");
+  }
+}
+async function readPosition(tokenId, mode, client) {
+  const { mode: baseMode } = (0, import_amm_core_v23.normalizeMode)(mode);
+  const manager = (0, import_amm_core_v23.KernelManagerAddress)(baseMode);
+  const c = resolveClient(mode, client);
+  try {
+    const raw = await c.readContract({
+      address: manager,
+      abi: import_amm_bindings.KernelManagerABI,
+      functionName: "nftPositions",
+      args: [tokenId]
+    });
+    const asTuple = Array.isArray(raw) ? raw : null;
+    if (asTuple) {
+      return {
+        pool: asTuple[0],
+        tickLower: asTuple[1],
+        tickUpper: asTuple[2],
+        liquidity: asTuple[3],
+        feeGrowthInside0LastX128: asTuple[4],
+        feeGrowthInside1LastX128: asTuple[5],
+        tokensOwed0: asTuple[6],
+        tokensOwed1: asTuple[7]
+      };
+    }
+    return raw;
+  } catch (err) {
+    throw wrapReadError(err, "readPosition");
+  }
+}
+async function readTickBitmap(kernelPool, wordPos, mode, client) {
+  const c = resolveClient(mode, client);
+  try {
+    const word = await c.readContract({
+      address: kernelPool,
+      abi: import_amm_bindings.KernelPoolABI,
+      functionName: "tickBitmap",
+      args: [wordPos]
+    });
+    return word;
+  } catch (err) {
+    throw wrapReadError(err, "readTickBitmap");
+  }
+}
+async function readTick(kernelPool, tick, mode, client) {
+  const c = resolveClient(mode, client);
+  try {
+    const raw = await c.readContract({
+      address: kernelPool,
+      abi: import_amm_bindings.KernelPoolABI,
+      functionName: "ticks",
+      args: [tick]
+    });
+    return {
+      liquidityGross: raw[0],
+      liquidityNet: raw[1],
+      feeGrowthOutside0X128: raw[2],
+      feeGrowthOutside1X128: raw[3],
+      tickCumulativeOutside: raw[4],
+      secondsPerLiquidityOutsideX128: raw[5],
+      secondsOutside: raw[6],
+      initialized: raw[7]
+    };
+  } catch (err) {
+    throw wrapReadError(err, "readTick");
+  }
+}
+async function computePositionAmounts(tokenId, mode, client) {
+  const c = resolveClient(mode, client);
+  const position = await readPosition(tokenId, mode, c);
+  const { slot0 } = await readPool(position.pool, mode, c);
+  const sqrtLower = getSqrtRatioAtTick(position.tickLower);
+  const sqrtUpper = getSqrtRatioAtTick(position.tickUpper);
+  if (slot0.tick < position.tickLower) {
+    return {
+      amount0: getAmount0Delta(sqrtLower, sqrtUpper, position.liquidity, false),
+      amount1: 0n
+    };
+  }
+  if (slot0.tick >= position.tickUpper) {
+    return {
+      amount0: 0n,
+      amount1: getAmount1Delta(sqrtLower, sqrtUpper, position.liquidity, false)
+    };
+  }
+  return {
+    amount0: getAmount0Delta(
+      slot0.sqrtPriceX96,
+      sqrtUpper,
+      position.liquidity,
+      false
+    ),
+    amount1: getAmount1Delta(
+      sqrtLower,
+      slot0.sqrtPriceX96,
+      position.liquidity,
+      false
+    )
+  };
+}
+
+// src/kernel/tickBitmap.ts
+function decodeTickBitmapWord(word, wordPos, tickSpacing) {
+  if (!Number.isSafeInteger(wordPos)) {
+    throw new RangeError(
+      `decodeTickBitmapWord: wordPos must be a safe integer, got ${wordPos}`
+    );
+  }
+  if (!Number.isSafeInteger(tickSpacing) || tickSpacing <= 0) {
+    throw new RangeError(
+      `decodeTickBitmapWord: tickSpacing must be a positive integer, got ${tickSpacing}`
+    );
+  }
+  const result = [];
+  const base = wordPos * 256;
+  for (let k = 0; k < 256; k++) {
+    if ((word >> BigInt(k) & 1n) === 1n) {
+      result.push((base + k) * tickSpacing);
+    }
+  }
+  return result;
+}
+
+// src/periphery/reader.ts
+var import_amm_bindings2 = require("@skate-org/amm-bindings");
+var import_amm_core_v24 = require("@skate-org/amm-core-v2");
+function resolveClient2(chain, mode, client) {
+  return client ?? getSourcePublicClient(chain, mode);
+}
+async function readPeripheryPool(chain, kernelPool, mode, client) {
+  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(mode);
+  const details = (0, import_amm_core_v24.getPeripheryDetailsByKernelPoolAndChainId)(
+    kernelPool,
+    chain,
+    baseMode
+  );
+  if (!details) {
+    throw new EvmReadError(
+      "readPeripheryPool",
+      `no periphery entry for kernelPool=${kernelPool} chain=${chain} mode=${baseMode}`
+    );
+  }
+  const address = details.address;
+  const c = resolveClient2(chain, mode, client);
+  try {
+    const [
+      balancesAvailableRaw,
+      dust0,
+      dust1,
+      token0,
+      token1,
+      fee,
+      kPool
+    ] = await Promise.all([
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "balancesAvailable"
+      }),
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "dustAmount0"
+      }),
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "dustAmount1"
+      }),
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "token0"
+      }),
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "token1"
+      }),
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "fee"
+      }),
+      c.readContract({
+        address,
+        abi: import_amm_bindings2.PeripheryPoolABI,
+        functionName: "kernelPool"
+      })
+    ]);
+    const bAvail = balancesAvailableRaw;
+    return {
+      address,
+      token0,
+      token1,
+      fee,
+      kernelPool: kPool,
+      balancesAvailable: {
+        amount0Available: bAvail[0],
+        amount1Available: bAvail[1]
+      },
+      dustAmount0: dust0,
+      dustAmount1: dust1
+    };
+  } catch (err) {
+    throw wrapReadError(err, "readPeripheryPool");
+  }
+}
+async function readUserPoolBalances(chain, kernelPool, user, mode, client) {
+  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(mode);
+  const details = (0, import_amm_core_v24.getPeripheryDetailsByKernelPoolAndChainId)(
+    kernelPool,
+    chain,
+    baseMode
+  );
+  if (!details) {
+    throw new EvmReadError(
+      "readUserPoolBalances",
+      `no periphery entry for kernelPool=${kernelPool} chain=${chain} mode=${baseMode}`
+    );
+  }
+  const c = resolveClient2(chain, mode, client);
+  try {
+    const raw = await c.readContract({
+      address: details.address,
+      abi: import_amm_bindings2.PeripheryPoolABI,
+      functionName: "usersData",
+      args: [user]
+    });
+    if (Array.isArray(raw)) {
+      const tuple = raw;
+      return { amount0: tuple[0], amount1: tuple[1] };
+    }
+    const asObject = raw;
+    return { amount0: asObject.amount0, amount1: asObject.amount1 };
+  } catch (err) {
+    throw wrapReadError(err, "readUserPoolBalances");
+  }
+}
+
+// src/periphery/submit.ts
+async function submitAction(wallet, params, _mode) {
+  if (wallet.chain?.id !== params.chain) {
+    throw new EvmWriteError(
+      "submitAction",
+      `wallet chain ${wallet.chain?.id ?? "undefined"} != params.chain ${params.chain}`
+    );
+  }
+  try {
+    const account = wallet.account;
+    if (!account) {
+      throw new EvmWriteError(
+        "submitAction",
+        "wallet has no account; callers must provide a wallet with wallet.account set"
+      );
+    }
+    return await wallet.sendTransaction({
+      to: params.to,
+      data: params.data,
+      value: params.value ?? 0n,
+      chain: wallet.chain,
+      account
+    });
+  } catch (err) {
+    if (err instanceof EvmWriteError) throw err;
+    throw wrapWriteError(err, "submitAction");
+  }
+}
+async function submitSwap(wallet, params, mode) {
+  try {
+    return await submitAction(wallet, params, mode);
+  } catch (err) {
+    if (err instanceof EvmWriteError) throw err;
+    throw wrapWriteError(err, "submitSwap");
+  }
+}
+async function submitApproval(wallet, params, mode) {
+  try {
+    return await submitAction(wallet, params, mode);
+  } catch (err) {
+    if (err instanceof EvmWriteError) throw err;
+    throw wrapWriteError(err, "submitApproval");
+  }
+}
+
+// src/events/kernel.ts
+var import_viem2 = require("viem");
+var import_amm_bindings3 = require("@skate-org/amm-bindings");
+var KERNEL_EVENT_NAMES = [
+  "Burn",
+  "Collect",
+  "CollectProtocol",
+  "IncreaseObservationCardinalityNext",
+  "Initialize",
+  "Mint",
+  "PeripheryPoolAdded",
+  "PeripheryPoolChanged",
+  "PoolCreated",
+  "PoolDescriptionUpdated",
+  "SetFeeProtocol",
+  "Swap"
+];
+function parseKernelEventLog(log) {
+  try {
+    const decoded = (0, import_viem2.decodeEventLog)({
+      abi: import_amm_bindings3.KernelEventEmitterABI,
+      data: log.data,
+      topics: log.topics
+    });
+    return {
+      eventName: decoded.eventName,
+      args: decoded.args ?? {},
+      log
+    };
+  } catch (err) {
+    const message = err.shortMessage ?? err.message ?? String(err);
+    throw new EvmReadError(
+      "parseKernelEventLog",
+      `failed to decode log: ${message}`,
+      { cause: err }
+    );
+  }
+}
+
+// src/events/periphery.ts
+var import_viem3 = require("viem");
+var import_amm_bindings4 = require("@skate-org/amm-bindings");
+var PERIPHERY_EVENT_NAMES = [
+  "AmountSettled",
+  "Burned",
+  "LiquidityDecreased",
+  "LiquidityIncreased",
+  "MintSettled",
+  "Minted",
+  "PoolCreated",
+  "PoolDeployed",
+  "Swapped",
+  "TransferredTo"
+];
+function parsePeripheryEventLog(log) {
+  try {
+    const decoded = (0, import_viem3.decodeEventLog)({
+      abi: import_amm_bindings4.PeripheryEventEmitterABI,
+      data: log.data,
+      topics: log.topics
+    });
+    return {
+      eventName: decoded.eventName,
+      args: decoded.args ?? {},
+      log
+    };
+  } catch (err) {
+    const message = err.shortMessage ?? err.message ?? String(err);
+    throw new EvmReadError(
+      "parsePeripheryEventLog",
+      `failed to decode log: ${message}`,
+      { cause: err }
+    );
+  }
+}
+
+// src/events/watch.ts
+var import_amm_bindings5 = require("@skate-org/amm-bindings");
+function watchKernelEvents(client, address, opts) {
+  return client.watchContractEvent({
+    abi: import_amm_bindings5.KernelEventEmitterABI,
+    address,
+    onLogs: (logs) => {
+      for (const log of logs) {
+        try {
+          opts.onEvent(parseKernelEventLog(log));
+        } catch (err) {
+          opts.onError?.(err);
+        }
+      }
+    }
+  });
+}
+function watchPeripheryEvents(client, address, opts) {
+  return client.watchContractEvent({
+    abi: import_amm_bindings5.PeripheryEventEmitterABI,
+    address,
+    onLogs: (logs) => {
+      for (const log of logs) {
+        try {
+          opts.onEvent(parsePeripheryEventLog(log));
+        } catch (err) {
+          opts.onError?.(err);
+        }
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DEV_API_ENDPOINT,
+  EvmReadError,
+  EvmWriteError,
+  KERNEL_EVENT_NAMES,
+  MAX_SQRT_RATIO,
+  MAX_TICK,
+  MIN_SQRT_RATIO,
+  MIN_TICK,
+  PERIPHERY_EVENT_NAMES,
+  addDelta,
+  computePositionAmounts,
+  createDevConfig,
+  decodeTickBitmapWord,
+  getAmount0Delta,
+  getAmount0DeltaSigned,
+  getAmount1Delta,
+  getAmount1DeltaSigned,
+  getKernelPublicClient,
+  getNextSqrtPriceFromAmount0RoundingUp,
+  getNextSqrtPriceFromAmount1RoundingDown,
+  getNextSqrtPriceFromInput,
+  getNextSqrtPriceFromOutput,
+  getSourcePublicClient,
+  getSqrtRatioAtTick,
+  getTickAtSqrtRatio,
+  megaethChain,
+  mulDiv,
+  mulDivRoundingUp,
+  parseKernelEventLog,
+  parsePeripheryEventLog,
+  readPeripheryPool,
+  readPool,
+  readPosition,
+  readTick,
+  readTickBitmap,
+  readUserPoolBalances,
+  submitAction,
+  submitApproval,
+  submitSwap,
+  watchKernelEvents,
+  watchPeripheryEvents
+});
+//# sourceMappingURL=index.cjs.map