@skate-org/amm-evm-v2 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/index.cjs

@@ -20,10 +20,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AmmEvm: () => AmmEvm,
   EvmReadError: () => EvmReadError,
   EvmWriteError: () => EvmWriteError,
   KERNEL_EVENT_NAMES: () => KERNEL_EVENT_NAMES,
   PERIPHERY_EVENT_NAMES: () => PERIPHERY_EVENT_NAMES,
+  SkateAmm: () => SkateAmm,
+  buildBurn: () => buildBurn,
+  buildDecreaseLiquidity: () => buildDecreaseLiquidity,
+  buildIncreaseLiquidity: () => buildIncreaseLiquidity,
+  buildMint: () => buildMint,
+  buildSwap: () => buildSwap,
   computePositionAmounts: () => computePositionAmounts,
   createDevConfig: () => createDevConfig,
   decodeTickBitmapWord: () => decodeTickBitmapWord,
@@ -32,6 +39,7 @@ __export(index_exports, {
   megaethChain: () => megaethChain,
   parseKernelEventLog: () => parseKernelEventLog,
   parsePeripheryEventLog: () => parsePeripheryEventLog,
+  readKernelBalances: () => readKernelBalances,
   readPeripheryPool: () => readPeripheryPool,
   readPool: () => readPool,
   readPosition: () => readPosition,
@@ -69,7 +77,8 @@ var megaethChain = (0, import_viem.defineChain)({
 });
 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"
+  [import_amm_core_v2.CHAIN.ARBITRUM]: "https://arb1.arbitrum.io/rpc",
+  [import_amm_core_v2.CHAIN.ETHEREUM]: "https://ethereum-rpc.publicnode.com"
 };
 function chainDefFor(chain) {
   switch (chain) {
@@ -77,6 +86,8 @@ function chainDefFor(chain) {
       return megaethChain;
     case import_amm_core_v2.CHAIN.ARBITRUM:
       return import_chains.arbitrum;
+    case import_amm_core_v2.CHAIN.ETHEREUM:
+      return import_chains.mainnet;
     default:
       return void 0;
   }
@@ -123,17 +134,9 @@ function getSourcePublicClient(chain, mode, transport) {
   });
 }
 
-// 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/kernel/reader.ts
+var import_amm_bindings = require("@skate-org/amm-bindings");
+var import_amm_core_v23 = require("@skate-org/amm-core-v2");
 
 // src/errors.ts
 var import_amm_core_v22 = require("@skate-org/amm-core-v2");
@@ -170,27 +173,23 @@ function wrapWriteError(err, functionName) {
   return new EvmWriteError(functionName, message, { cause: err });
 }
 
-// src/kernel/reader.ts
-var import_amm_bindings = require("@skate-org/amm-bindings");
-var import_amm_core_v23 = require("@skate-org/amm-core-v2");
-
 // src/kernel/_client.ts
 function resolveKernelClient(mode, client) {
   return client ?? getKernelPublicClient(mode);
 }
 
 // src/kernel/reader.ts
-async function readPool(kernelPool, mode, client) {
-  const c = resolveKernelClient(mode, client);
+async function readPool(p) {
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const [slot0, liquidity] = await Promise.all([
       c.readContract({
-        address: kernelPool,
+        address: p.kernelPool,
         abi: import_amm_bindings.KernelPoolABI,
         functionName: "slot0"
       }),
       c.readContract({
-        address: kernelPool,
+        address: p.kernelPool,
         abi: import_amm_bindings.KernelPoolABI,
         functionName: "liquidity"
       })
@@ -212,16 +211,36 @@ async function readPool(kernelPool, mode, client) {
     throw wrapReadError(err, "readPool");
   }
 }
-async function readPosition(tokenId, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v23.normalizeMode)(mode);
+async function readKernelBalances(p) {
+  const c = resolveKernelClient(p.mode, p.client);
+  try {
+    const [balance0, balance1] = await Promise.all([
+      c.readContract({
+        address: p.kernelPool,
+        abi: import_amm_bindings.KernelPoolABI,
+        functionName: "balance0"
+      }),
+      c.readContract({
+        address: p.kernelPool,
+        abi: import_amm_bindings.KernelPoolABI,
+        functionName: "balance1"
+      })
+    ]);
+    return { balance0, balance1 };
+  } catch (err) {
+    throw wrapReadError(err, "readKernelBalances");
+  }
+}
+async function readPosition(p) {
+  const { mode: baseMode } = (0, import_amm_core_v23.normalizeMode)(p.mode);
   const manager = (0, import_amm_core_v23.KernelManagerAddress)(baseMode);
-  const c = resolveKernelClient(mode, client);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const raw = await c.readContract({
       address: manager,
       abi: import_amm_bindings.KernelManagerABI,
       functionName: "nftPositions",
-      args: [tokenId]
+      args: [p.tokenId]
     });
     const asTuple = Array.isArray(raw) ? raw : null;
     if (asTuple) {
@@ -241,28 +260,28 @@ async function readPosition(tokenId, mode, client) {
     throw wrapReadError(err, "readPosition");
   }
 }
-async function readTickBitmap(kernelPool, wordPos, mode, client) {
-  const c = resolveKernelClient(mode, client);
+async function readTickBitmap(p) {
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const word = await c.readContract({
-      address: kernelPool,
+      address: p.kernelPool,
       abi: import_amm_bindings.KernelPoolABI,
       functionName: "tickBitmap",
-      args: [wordPos]
+      args: [p.wordPos]
     });
     return word;
   } catch (err) {
     throw wrapReadError(err, "readTickBitmap");
   }
 }
-async function readTick(kernelPool, tick, mode, client) {
-  const c = resolveKernelClient(mode, client);
+async function readTick(p) {
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const raw = await c.readContract({
-      address: kernelPool,
+      address: p.kernelPool,
       abi: import_amm_bindings.KernelPoolABI,
       functionName: "ticks",
-      args: [tick]
+      args: [p.tick]
     });
     return {
       liquidityGross: raw[0],
@@ -278,10 +297,10 @@ async function readTick(kernelPool, tick, mode, client) {
     throw wrapReadError(err, "readTick");
   }
 }
-async function computePositionAmounts(tokenId, mode, client) {
-  const c = resolveKernelClient(mode, client);
-  const position = await readPosition(tokenId, mode, c);
-  const { slot0 } = await readPool(position.pool, mode, c);
+async function computePositionAmounts(p) {
+  const c = resolveKernelClient(p.mode, p.client);
+  const position = await readPosition({ tokenId: p.tokenId, mode: p.mode, client: c });
+  const { slot0 } = await readPool({ kernelPool: position.pool, mode: p.mode, client: c });
   const sqrtLower = (0, import_amm_core_v23.getSqrtRatioAtTick)(position.tickLower);
   const sqrtUpper = (0, import_amm_core_v23.getSqrtRatioAtTick)(position.tickUpper);
   if (slot0.tick < position.tickLower) {
@@ -312,45 +331,23 @@ async function computePositionAmounts(tokenId, mode, client) {
   };
 }
 
-// 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/kernel/lens.ts
 var import_amm_bindings2 = require("@skate-org/amm-bindings");
 var import_amm_core_v24 = require("@skate-org/amm-core-v2");
-async function simulateSwap(params, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateSwap(p) {
+  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: (0, import_amm_core_v24.KernelManagerAddress)(baseMode),
       abi: import_amm_bindings2.KernelManagerABI,
       functionName: "lensSwap",
       args: [
-        params.pool,
-        params.recipient,
-        params.zeroForOne,
-        params.amountSpecified,
-        params.sqrtPriceLimitX96
+        p.params.pool,
+        p.params.recipient,
+        p.params.zeroForOne,
+        p.params.amountSpecified,
+        p.params.sqrtPriceLimitX96
       ]
     });
     const [amount0, amount1, sqrtPriceX96After, returnData] = out.result;
@@ -359,22 +356,22 @@ async function simulateSwap(params, mode, client) {
     throw wrapReadError(err, "simulateSwap");
   }
 }
-async function simulateMint(params, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateMint(p) {
+  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: (0, import_amm_core_v24.KernelManagerAddress)(baseMode),
       abi: import_amm_bindings2.KernelManagerABI,
       functionName: "lensMint",
       args: [
-        params.pool,
-        params.recipient,
-        params.tickLower,
-        params.tickUpper,
-        params.amount0,
-        params.amount1,
-        params.data
+        p.params.pool,
+        p.params.recipient,
+        p.params.tickLower,
+        p.params.tickUpper,
+        p.params.amount0,
+        p.params.amount1,
+        p.params.data
       ]
     });
     const [amount0Used, amount1Used, liquidityAmount, returnData] = out.result;
@@ -383,20 +380,20 @@ async function simulateMint(params, mode, client) {
     throw wrapReadError(err, "simulateMint");
   }
 }
-async function simulateBurn(params, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateBurn(p) {
+  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: (0, import_amm_core_v24.KernelManagerAddress)(baseMode),
       abi: import_amm_bindings2.KernelManagerABI,
       functionName: "lensBurn",
       args: [
-        params.pool,
-        params.recipient,
-        params.tickLower,
-        params.tickUpper,
-        params.amount
+        p.params.pool,
+        p.params.recipient,
+        p.params.tickLower,
+        p.params.tickUpper,
+        p.params.amount
       ]
     });
     const [amount0, amount1, returnData] = out.result;
@@ -405,15 +402,15 @@ async function simulateBurn(params, mode, client) {
     throw wrapReadError(err, "simulateBurn");
   }
 }
-async function simulateDecreaseLiquidity(params, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateDecreaseLiquidity(p) {
+  const { mode: baseMode } = (0, import_amm_core_v24.normalizeMode)(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: (0, import_amm_core_v24.KernelManagerAddress)(baseMode),
       abi: import_amm_bindings2.KernelManagerABI,
       functionName: "lensDecreaseLiquidity",
-      args: [params.tokenId, params.liquidity]
+      args: [p.params.tokenId, p.params.liquidity]
     });
     const [amount0, amount1, returnData] = out.result;
     return { amount0, amount1, returnData };
@@ -428,21 +425,21 @@ var import_amm_core_v25 = require("@skate-org/amm-core-v2");
 function resolveClient(chain, mode, client) {
   return client ?? getSourcePublicClient(chain, mode);
 }
-async function readPeripheryPool(chain, kernelPool, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v25.normalizeMode)(mode);
+async function readPeripheryPool(p) {
+  const { mode: baseMode } = (0, import_amm_core_v25.normalizeMode)(p.mode);
   const details = (0, import_amm_core_v25.getPeripheryDetailsByKernelPoolAndChainId)(
-    kernelPool,
-    chain,
+    p.kernelPool,
+    p.chain,
     baseMode
   );
   if (!details) {
     throw new EvmReadError(
       "readPeripheryPool",
-      `no periphery entry for kernelPool=${kernelPool} chain=${chain} mode=${baseMode}`
+      `no periphery entry for kernelPool=${p.kernelPool} chain=${p.chain} mode=${baseMode}`
     );
   }
   const address = details.address;
-  const c = resolveClient(chain, mode, client);
+  const c = resolveClient(p.chain, p.mode, p.client);
   try {
     const [
       balancesAvailableRaw,
@@ -507,26 +504,24 @@ async function readPeripheryPool(chain, kernelPool, mode, client) {
     throw wrapReadError(err, "readPeripheryPool");
   }
 }
-async function readUserPoolBalances(chain, kernelPool, user, mode, client) {
-  const { mode: baseMode } = (0, import_amm_core_v25.normalizeMode)(mode);
-  const details = (0, import_amm_core_v25.getPeripheryDetailsByKernelPoolAndChainId)(
-    kernelPool,
-    chain,
-    baseMode
-  );
-  if (!details) {
+async function readUserPoolBalances(p) {
+  const { mode: baseMode } = (0, import_amm_core_v25.normalizeMode)(p.mode);
+  const core = new import_amm_core_v25.AmmCore(p.mode);
+  const info = core.getPoolInfoByKey(p.poolKey);
+  const periphery = info?.peripheryInfo[p.chain];
+  if (!periphery?.address) {
     throw new EvmReadError(
       "readUserPoolBalances",
-      `no periphery entry for kernelPool=${kernelPool} chain=${chain} mode=${baseMode}`
+      `no periphery entry for poolKey=${p.poolKey} chain=${p.chain} mode=${baseMode}`
     );
   }
-  const c = resolveClient(chain, mode, client);
+  const c = resolveClient(p.chain, p.mode, p.client);
   try {
     const raw = await c.readContract({
-      address: details.address,
+      address: periphery.address,
       abi: import_amm_bindings3.PeripheryPoolABI,
       functionName: "usersData",
-      args: [user]
+      args: [p.user]
     });
     if (Array.isArray(raw)) {
       const tuple = raw;
@@ -584,9 +579,403 @@ async function submitApproval(wallet, params, mode) {
   }
 }
 
-// src/events/kernel.ts
+// src/periphery/calldata.ts
 var import_viem2 = require("viem");
 var import_amm_bindings4 = require("@skate-org/amm-bindings");
+var import_amm_core_v26 = require("@skate-org/amm-core-v2");
+function resolvePeripheryTarget(poolKey, chain, mode) {
+  const core = new import_amm_core_v26.AmmCore(mode);
+  const info = core.getPoolInfoByKey(poolKey);
+  if (!info) throw new Error(`unknown poolKey: ${poolKey}`);
+  const periphery = info.peripheryInfo[chain];
+  if (!periphery?.address) {
+    throw new Error(`pool ${poolKey} has no periphery on chain ${chain}`);
+  }
+  return periphery.address;
+}
+function encodeSwap(params) {
+  const {
+    recipient,
+    zeroForOne,
+    amount,
+    sqrtPriceLimitX96,
+    destVmType,
+    destChainId,
+    minAmountOut,
+    deadline
+  } = params;
+  const extraData = (0, import_viem2.encodeAbiParameters)(
+    (0, import_viem2.parseAbiParameters)("uint256,uint256,uint256,uint256"),
+    [
+      minAmountOut ?? 0n,
+      BigInt(destChainId),
+      BigInt(destVmType),
+      deadline ?? import_viem2.maxUint256
+    ]
+  );
+  return (0, import_viem2.encodeFunctionData)({
+    abi: import_amm_bindings4.PeripheryPoolABI,
+    functionName: "swap",
+    args: [recipient, zeroForOne, amount, sqrtPriceLimitX96, extraData]
+  });
+}
+function encodeMint(params) {
+  const {
+    recipient,
+    tickLower,
+    tickUpper,
+    amount0,
+    amount1,
+    amount0Min,
+    amount1Min,
+    deadline
+  } = params;
+  const extraData = (0, import_viem2.encodeAbiParameters)(
+    (0, import_viem2.parseAbiParameters)("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? import_viem2.maxUint256]
+  );
+  return (0, import_viem2.encodeFunctionData)({
+    abi: import_amm_bindings4.PeripheryPoolABI,
+    functionName: "mint",
+    args: [recipient, tickLower, tickUpper, amount0, amount1, extraData]
+  });
+}
+function encodeBurn(params) {
+  const { tokenId, amount0Min, amount1Min, deadline } = params;
+  const extraData = (0, import_viem2.encodeAbiParameters)(
+    (0, import_viem2.parseAbiParameters)("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? import_viem2.maxUint256]
+  );
+  return (0, import_viem2.encodeFunctionData)({
+    abi: import_amm_bindings4.PeripheryPoolABI,
+    functionName: "burn",
+    args: [tokenId, extraData]
+  });
+}
+function encodeIncreaseLiquidity(params) {
+  const { tokenId, amount0, amount1, amount0Min, amount1Min, deadline } = params;
+  const extraData = (0, import_viem2.encodeAbiParameters)(
+    (0, import_viem2.parseAbiParameters)("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? import_viem2.maxUint256]
+  );
+  return (0, import_viem2.encodeFunctionData)({
+    abi: import_amm_bindings4.PeripheryPoolABI,
+    functionName: "increaseLiquidity",
+    args: [tokenId, amount0, amount1, extraData]
+  });
+}
+function encodeDecreaseLiquidity(params) {
+  const { tokenId, liquidityAmount, amount0Min, amount1Min, deadline } = params;
+  const extraData = (0, import_viem2.encodeAbiParameters)(
+    (0, import_viem2.parseAbiParameters)("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? import_viem2.maxUint256]
+  );
+  return (0, import_viem2.encodeFunctionData)({
+    abi: import_amm_bindings4.PeripheryPoolABI,
+    functionName: "decreaseLiquidity",
+    args: [tokenId, liquidityAmount, extraData]
+  });
+}
+async function buildSwap(params) {
+  const { poolKey, chain, mode, ...encodeParams } = params;
+  return {
+    target: resolvePeripheryTarget(poolKey, chain, mode),
+    calldata: encodeSwap(encodeParams)
+  };
+}
+async function buildMint(params) {
+  const { poolKey, chain, mode, ...encodeParams } = params;
+  return {
+    target: resolvePeripheryTarget(poolKey, chain, mode),
+    calldata: encodeMint(encodeParams)
+  };
+}
+async function buildBurn(params) {
+  const { poolKey, chain, mode, ...encodeParams } = params;
+  return {
+    target: resolvePeripheryTarget(poolKey, chain, mode),
+    calldata: encodeBurn(encodeParams)
+  };
+}
+async function buildIncreaseLiquidity(params) {
+  const { poolKey, chain, mode, ...encodeParams } = params;
+  return {
+    target: resolvePeripheryTarget(poolKey, chain, mode),
+    calldata: encodeIncreaseLiquidity(encodeParams)
+  };
+}
+async function buildDecreaseLiquidity(params) {
+  const { poolKey, chain, mode, ...encodeParams } = params;
+  return {
+    target: resolvePeripheryTarget(poolKey, chain, mode),
+    calldata: encodeDecreaseLiquidity(encodeParams)
+  };
+}
+
+// src/client.ts
+var AmmEvm = class {
+  env;
+  constructor(env) {
+    this.env = env;
+  }
+  // ── Kernel readers ────────────────────────────────────────────────────────
+  readPool(p) {
+    return readPool({ ...p, mode: this.env, client: p.client });
+  }
+  readKernelBalances(p) {
+    return readKernelBalances({ ...p, mode: this.env, client: p.client });
+  }
+  readPosition(p) {
+    return readPosition({ ...p, mode: this.env, client: p.client });
+  }
+  readTickBitmap(p) {
+    return readTickBitmap({ ...p, mode: this.env, client: p.client });
+  }
+  readTick(p) {
+    return readTick({ ...p, mode: this.env, client: p.client });
+  }
+  computePositionAmounts(p) {
+    return computePositionAmounts({ ...p, mode: this.env, client: p.client });
+  }
+  // ── Kernel lens (simulate) ────────────────────────────────────────────────
+  simulateSwap(p) {
+    return simulateSwap({ ...p, mode: this.env, client: p.client });
+  }
+  simulateMint(p) {
+    return simulateMint({ ...p, mode: this.env, client: p.client });
+  }
+  simulateBurn(p) {
+    return simulateBurn({ ...p, mode: this.env, client: p.client });
+  }
+  simulateDecreaseLiquidity(p) {
+    return simulateDecreaseLiquidity({ ...p, mode: this.env, client: p.client });
+  }
+  // ── Periphery readers ─────────────────────────────────────────────────────
+  readPeripheryPool(p) {
+    return readPeripheryPool({ ...p, mode: this.env, client: p.client });
+  }
+  readUserPoolBalances(p) {
+    return readUserPoolBalances({ ...p, mode: this.env, client: p.client });
+  }
+  // ── Periphery calldata builders ───────────────────────────────────────────
+  buildSwap(p) {
+    return buildSwap({ ...p, mode: this.env });
+  }
+  buildMint(p) {
+    return buildMint({ ...p, mode: this.env });
+  }
+  buildBurn(p) {
+    return buildBurn({ ...p, mode: this.env });
+  }
+  buildIncreaseLiquidity(p) {
+    return buildIncreaseLiquidity({ ...p, mode: this.env });
+  }
+  buildDecreaseLiquidity(p) {
+    return buildDecreaseLiquidity({ ...p, mode: this.env });
+  }
+  // ── Periphery submitters ──────────────────────────────────────────────────
+  submitAction(wallet, params) {
+    return submitAction(wallet, params, this.env);
+  }
+  submitSwap(wallet, params) {
+    return submitSwap(wallet, params, this.env);
+  }
+  submitApproval(wallet, params) {
+    return submitApproval(wallet, params, this.env);
+  }
+  /** EVM submits any action via the same path — alias of `submitAction`. */
+  submitMint(wallet, params) {
+    return submitAction(wallet, params, this.env);
+  }
+  /** EVM submits any action via the same path — alias of `submitAction`. */
+  submitBurn(wallet, params) {
+    return submitAction(wallet, params, this.env);
+  }
+  /** EVM submits any action via the same path — alias of `submitAction`. */
+  submitIncreaseLiquidity(wallet, params) {
+    return submitAction(wallet, params, this.env);
+  }
+  /** EVM submits any action via the same path — alias of `submitAction`. */
+  submitDecreaseLiquidity(wallet, params) {
+    return submitAction(wallet, params, this.env);
+  }
+  // ── Chain-client factories ────────────────────────────────────────────────
+  getKernelPublicClient(transport) {
+    return getKernelPublicClient(this.env, transport);
+  }
+  getSourcePublicClient(chain, transport) {
+    return getSourcePublicClient(chain, this.env, transport);
+  }
+};
+
+// src/skate-amm.ts
+var import_amm_core_v27 = require("@skate-org/amm-core-v2");
+var import_amm_api_v2 = require("@skate-org/amm-api-v2");
+var SkateAmm = class {
+  env;
+  core;
+  api;
+  vm;
+  quote;
+  actions;
+  pools;
+  constructor(env) {
+    this.env = env;
+    this.core = new import_amm_core_v27.AmmCore(env);
+    this.api = new import_amm_api_v2.AmmApi(env);
+    this.vm = new AmmEvm(env);
+    const api = this.api;
+    const core = this.core;
+    this.quote = {
+      swap: api.swapQuote.bind(api),
+      mint: api.mintQuote.bind(api),
+      burn: api.burnQuote.bind(api),
+      increaseLiquidity: api.increaseLiquidityQuote.bind(api),
+      decreaseLiquidity: api.decreaseLiquidityQuote.bind(api),
+      boostedMint: api.boostedMintQuote.bind(api),
+      boostedRange: api.boostedRangeQuote.bind(api),
+      streamSwap: api.streamSwapQuote.bind(api),
+      subscribeSwap: api.subscribeSwapQuote.bind(api)
+    };
+    this.actions = {
+      get: api.getAction.bind(api),
+      byUser: api.getActionsByUser.bind(api),
+      byUserTimeRange: api.getActionsByUserTimeRange.bind(api),
+      waitForExecuted: api.waitForExecuted.bind(api),
+      position: api.getPosition.bind(api)
+    };
+    this.pools = {
+      all: core.getAllPoolInfo.bind(core),
+      keys: core.getAllPoolKeys.bind(core),
+      byKey: core.getPoolInfoByKey.bind(core),
+      supportedChains: core.getSupportedChains.bind(core),
+      supportedPairs: core.getSupportedPairs.bind(core),
+      supportedTokens: core.getSupportedTokens.bind(core),
+      keyByKernelPool: core.kernelPoolToPoolKey.bind(core)
+    };
+  }
+  // ── AmmVmClient: builders ────────────────────────────────────────────────────
+  buildSwap(p) {
+    return this.vm.buildSwap(p);
+  }
+  buildMint(p) {
+    return this.vm.buildMint(p);
+  }
+  buildBurn(p) {
+    return this.vm.buildBurn(p);
+  }
+  buildIncreaseLiquidity(p) {
+    return this.vm.buildIncreaseLiquidity(p);
+  }
+  buildDecreaseLiquidity(p) {
+    return this.vm.buildDecreaseLiquidity(p);
+  }
+  // ── AmmVmClient: submitters ──────────────────────────────────────────────────
+  submitSwap(w, p) {
+    return this.vm.submitSwap(w, p);
+  }
+  submitMint(w, p) {
+    return this.vm.submitMint(w, p);
+  }
+  submitBurn(w, p) {
+    return this.vm.submitBurn(w, p);
+  }
+  submitIncreaseLiquidity(w, p) {
+    return this.vm.submitIncreaseLiquidity(w, p);
+  }
+  submitDecreaseLiquidity(w, p) {
+    return this.vm.submitDecreaseLiquidity(w, p);
+  }
+  // ── AmmVmClient: readers ─────────────────────────────────────────────────────
+  readPeripheryPool(p) {
+    return this.vm.readPeripheryPool(p);
+  }
+  readUserPoolBalances(p) {
+    return this.vm.readUserPoolBalances(p);
+  }
+  // ── EVM extras ───────────────────────────────────────────────────────────────
+  /** Read raw kernel pool slot. */
+  readPool(p) {
+    return this.vm.readPool(p);
+  }
+  readKernelBalances(p) {
+    return this.vm.readKernelBalances(p);
+  }
+  readPosition(p) {
+    return this.vm.readPosition(p);
+  }
+  readTickBitmap(p) {
+    return this.vm.readTickBitmap(p);
+  }
+  readTick(p) {
+    return this.vm.readTick(p);
+  }
+  computePositionAmounts(p) {
+    return this.vm.computePositionAmounts(p);
+  }
+  simulateSwap(p) {
+    return this.vm.simulateSwap(p);
+  }
+  simulateMint(p) {
+    return this.vm.simulateMint(p);
+  }
+  simulateBurn(p) {
+    return this.vm.simulateBurn(p);
+  }
+  simulateDecreaseLiquidity(p) {
+    return this.vm.simulateDecreaseLiquidity(p);
+  }
+  submitAction(w, p) {
+    return this.vm.submitAction(w, p);
+  }
+  submitApproval(w, p) {
+    return this.vm.submitApproval(w, p);
+  }
+  getKernelPublicClient(...args) {
+    return this.vm.getKernelPublicClient(...args);
+  }
+  getSourcePublicClient(...args) {
+    return this.vm.getSourcePublicClient(...args);
+  }
+};
+
+// 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/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/events/kernel.ts
+var import_viem3 = require("viem");
+var import_amm_bindings5 = require("@skate-org/amm-bindings");
 var KERNEL_EVENT_NAMES = [
   "Burn",
   "Collect",
@@ -603,8 +992,8 @@ var KERNEL_EVENT_NAMES = [
 ];
 function parseKernelEventLog(log) {
   try {
-    const decoded = (0, import_viem2.decodeEventLog)({
-      abi: import_amm_bindings4.KernelEventEmitterABI,
+    const decoded = (0, import_viem3.decodeEventLog)({
+      abi: import_amm_bindings5.KernelEventEmitterABI,
       data: log.data,
       topics: log.topics
     });
@@ -624,8 +1013,8 @@ function parseKernelEventLog(log) {
 }
 
 // src/events/periphery.ts
-var import_viem3 = require("viem");
-var import_amm_bindings5 = require("@skate-org/amm-bindings");
+var import_viem4 = require("viem");
+var import_amm_bindings6 = require("@skate-org/amm-bindings");
 var PERIPHERY_EVENT_NAMES = [
   "AmountSettled",
   "Burned",
@@ -640,8 +1029,8 @@ var PERIPHERY_EVENT_NAMES = [
 ];
 function parsePeripheryEventLog(log) {
   try {
-    const decoded = (0, import_viem3.decodeEventLog)({
-      abi: import_amm_bindings5.PeripheryEventEmitterABI,
+    const decoded = (0, import_viem4.decodeEventLog)({
+      abi: import_amm_bindings6.PeripheryEventEmitterABI,
       data: log.data,
       topics: log.topics
     });
@@ -661,10 +1050,10 @@ function parsePeripheryEventLog(log) {
 }
 
 // src/events/watch.ts
-var import_amm_bindings6 = require("@skate-org/amm-bindings");
+var import_amm_bindings7 = require("@skate-org/amm-bindings");
 function watchKernelEvents(client, address, opts) {
   return client.watchContractEvent({
-    abi: import_amm_bindings6.KernelEventEmitterABI,
+    abi: import_amm_bindings7.KernelEventEmitterABI,
     address,
     onLogs: (logs) => {
       for (const log of logs) {
@@ -679,7 +1068,7 @@ function watchKernelEvents(client, address, opts) {
 }
 function watchPeripheryEvents(client, address, opts) {
   return client.watchContractEvent({
-    abi: import_amm_bindings6.PeripheryEventEmitterABI,
+    abi: import_amm_bindings7.PeripheryEventEmitterABI,
     address,
     onLogs: (logs) => {
       for (const log of logs) {
@@ -694,10 +1083,17 @@ function watchPeripheryEvents(client, address, opts) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AmmEvm,
   EvmReadError,
   EvmWriteError,
   KERNEL_EVENT_NAMES,
   PERIPHERY_EVENT_NAMES,
+  SkateAmm,
+  buildBurn,
+  buildDecreaseLiquidity,
+  buildIncreaseLiquidity,
+  buildMint,
+  buildSwap,
   computePositionAmounts,
   createDevConfig,
   decodeTickBitmapWord,
@@ -706,6 +1102,7 @@ function watchPeripheryEvents(client, address, opts) {
   megaethChain,
   parseKernelEventLog,
   parsePeripheryEventLog,
+  readKernelBalances,
   readPeripheryPool,
   readPool,
   readPosition,