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

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   defineChain,
   http
 } from "viem";
-import { arbitrum } from "viem/chains";
+import { arbitrum, mainnet } from "viem/chains";
 import {
   BLOCK_EXPLORER,
   CHAIN,
@@ -28,7 +28,8 @@ var megaethChain = defineChain({
 });
 var DEFAULT_RPC = {
   [CHAIN.MEGAETH]: "https://mainnet.megaeth.com/rpc",
-  [CHAIN.ARBITRUM]: "https://arb1.arbitrum.io/rpc"
+  [CHAIN.ARBITRUM]: "https://arb1.arbitrum.io/rpc",
+  [CHAIN.ETHEREUM]: "https://ethereum-rpc.publicnode.com"
 };
 function chainDefFor(chain) {
   switch (chain) {
@@ -36,6 +37,8 @@ function chainDefFor(chain) {
       return megaethChain;
     case CHAIN.ARBITRUM:
       return arbitrum;
+    case CHAIN.ETHEREUM:
+      return mainnet;
     default:
       return void 0;
   }
@@ -82,17 +85,18 @@ 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
+import {
+  KernelManagerABI,
+  KernelPoolABI
+} from "@skate-org/amm-bindings";
+import {
+  KernelManagerAddress,
+  normalizeMode as normalizeMode2,
+  getAmount0Delta,
+  getAmount1Delta,
+  getSqrtRatioAtTick
+} from "@skate-org/amm-core-v2";
 
 // src/errors.ts
 import { SdkError } from "@skate-org/amm-core-v2";
@@ -129,36 +133,23 @@ function wrapWriteError(err, functionName) {
   return new EvmWriteError(functionName, message, { cause: err });
 }
 
-// src/kernel/reader.ts
-import {
-  KernelManagerABI,
-  KernelPoolABI
-} from "@skate-org/amm-bindings";
-import {
-  KernelManagerAddress,
-  normalizeMode as normalizeMode2,
-  getAmount0Delta,
-  getAmount1Delta,
-  getSqrtRatioAtTick
-} from "@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: KernelPoolABI,
         functionName: "slot0"
       }),
       c.readContract({
-        address: kernelPool,
+        address: p.kernelPool,
         abi: KernelPoolABI,
         functionName: "liquidity"
       })
@@ -180,16 +171,36 @@ async function readPool(kernelPool, mode, client) {
     throw wrapReadError(err, "readPool");
   }
 }
-async function readPosition(tokenId, mode, client) {
-  const { mode: baseMode } = normalizeMode2(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: KernelPoolABI,
+        functionName: "balance0"
+      }),
+      c.readContract({
+        address: p.kernelPool,
+        abi: KernelPoolABI,
+        functionName: "balance1"
+      })
+    ]);
+    return { balance0, balance1 };
+  } catch (err) {
+    throw wrapReadError(err, "readKernelBalances");
+  }
+}
+async function readPosition(p) {
+  const { mode: baseMode } = normalizeMode2(p.mode);
   const manager = KernelManagerAddress(baseMode);
-  const c = resolveKernelClient(mode, client);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const raw = await c.readContract({
       address: manager,
       abi: KernelManagerABI,
       functionName: "nftPositions",
-      args: [tokenId]
+      args: [p.tokenId]
     });
     const asTuple = Array.isArray(raw) ? raw : null;
     if (asTuple) {
@@ -209,28 +220,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: 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: KernelPoolABI,
       functionName: "ticks",
-      args: [tick]
+      args: [p.tick]
     });
     return {
       liquidityGross: raw[0],
@@ -246,10 +257,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 = getSqrtRatioAtTick(position.tickLower);
   const sqrtUpper = getSqrtRatioAtTick(position.tickUpper);
   if (slot0.tick < position.tickLower) {
@@ -280,48 +291,26 @@ 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
 import { KernelManagerABI as KernelManagerABI2 } from "@skate-org/amm-bindings";
 import {
   KernelManagerAddress as KernelManagerAddress2,
   normalizeMode as normalizeMode3
 } from "@skate-org/amm-core-v2";
-async function simulateSwap(params, mode, client) {
-  const { mode: baseMode } = normalizeMode3(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateSwap(p) {
+  const { mode: baseMode } = normalizeMode3(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: KernelManagerAddress2(baseMode),
       abi: KernelManagerABI2,
       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;
@@ -330,22 +319,22 @@ async function simulateSwap(params, mode, client) {
     throw wrapReadError(err, "simulateSwap");
   }
 }
-async function simulateMint(params, mode, client) {
-  const { mode: baseMode } = normalizeMode3(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateMint(p) {
+  const { mode: baseMode } = normalizeMode3(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: KernelManagerAddress2(baseMode),
       abi: KernelManagerABI2,
       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;
@@ -354,20 +343,20 @@ async function simulateMint(params, mode, client) {
     throw wrapReadError(err, "simulateMint");
   }
 }
-async function simulateBurn(params, mode, client) {
-  const { mode: baseMode } = normalizeMode3(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateBurn(p) {
+  const { mode: baseMode } = normalizeMode3(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: KernelManagerAddress2(baseMode),
       abi: KernelManagerABI2,
       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;
@@ -376,15 +365,15 @@ async function simulateBurn(params, mode, client) {
     throw wrapReadError(err, "simulateBurn");
   }
 }
-async function simulateDecreaseLiquidity(params, mode, client) {
-  const { mode: baseMode } = normalizeMode3(mode);
-  const c = resolveKernelClient(mode, client);
+async function simulateDecreaseLiquidity(p) {
+  const { mode: baseMode } = normalizeMode3(p.mode);
+  const c = resolveKernelClient(p.mode, p.client);
   try {
     const out = await c.simulateContract({
       address: KernelManagerAddress2(baseMode),
       abi: KernelManagerABI2,
       functionName: "lensDecreaseLiquidity",
-      args: [params.tokenId, params.liquidity]
+      args: [p.params.tokenId, p.params.liquidity]
     });
     const [amount0, amount1, returnData] = out.result;
     return { amount0, amount1, returnData };
@@ -396,27 +385,28 @@ async function simulateDecreaseLiquidity(params, mode, client) {
 // src/periphery/reader.ts
 import { PeripheryPoolABI } from "@skate-org/amm-bindings";
 import {
+  AmmCore,
   getPeripheryDetailsByKernelPoolAndChainId,
   normalizeMode as normalizeMode4
 } from "@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 } = normalizeMode4(mode);
+async function readPeripheryPool(p) {
+  const { mode: baseMode } = normalizeMode4(p.mode);
   const details = 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,
@@ -481,26 +471,24 @@ async function readPeripheryPool(chain, kernelPool, mode, client) {
     throw wrapReadError(err, "readPeripheryPool");
   }
 }
-async function readUserPoolBalances(chain, kernelPool, user, mode, client) {
-  const { mode: baseMode } = normalizeMode4(mode);
-  const details = getPeripheryDetailsByKernelPoolAndChainId(
-    kernelPool,
-    chain,
-    baseMode
-  );
-  if (!details) {
+async function readUserPoolBalances(p) {
+  const { mode: baseMode } = normalizeMode4(p.mode);
+  const core = new 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: PeripheryPoolABI,
       functionName: "usersData",
-      args: [user]
+      args: [p.user]
     });
     if (Array.isArray(raw)) {
       const tuple = raw;
@@ -558,6 +546,407 @@ async function submitApproval(wallet, params, mode) {
   }
 }
 
+// src/periphery/calldata.ts
+import {
+  encodeAbiParameters,
+  encodeFunctionData,
+  maxUint256,
+  parseAbiParameters
+} from "viem";
+import { PeripheryPoolABI as PeripheryPoolABI2 } from "@skate-org/amm-bindings";
+import {
+  AmmCore as AmmCore2
+} from "@skate-org/amm-core-v2";
+function resolvePeripheryTarget(poolKey, chain, mode) {
+  const core = new AmmCore2(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 = encodeAbiParameters(
+    parseAbiParameters("uint256,uint256,uint256,uint256"),
+    [
+      minAmountOut ?? 0n,
+      BigInt(destChainId),
+      BigInt(destVmType),
+      deadline ?? maxUint256
+    ]
+  );
+  return encodeFunctionData({
+    abi: PeripheryPoolABI2,
+    functionName: "swap",
+    args: [recipient, zeroForOne, amount, sqrtPriceLimitX96, extraData]
+  });
+}
+function encodeMint(params) {
+  const {
+    recipient,
+    tickLower,
+    tickUpper,
+    amount0,
+    amount1,
+    amount0Min,
+    amount1Min,
+    deadline
+  } = params;
+  const extraData = encodeAbiParameters(
+    parseAbiParameters("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? maxUint256]
+  );
+  return encodeFunctionData({
+    abi: PeripheryPoolABI2,
+    functionName: "mint",
+    args: [recipient, tickLower, tickUpper, amount0, amount1, extraData]
+  });
+}
+function encodeBurn(params) {
+  const { tokenId, amount0Min, amount1Min, deadline } = params;
+  const extraData = encodeAbiParameters(
+    parseAbiParameters("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? maxUint256]
+  );
+  return encodeFunctionData({
+    abi: PeripheryPoolABI2,
+    functionName: "burn",
+    args: [tokenId, extraData]
+  });
+}
+function encodeIncreaseLiquidity(params) {
+  const { tokenId, amount0, amount1, amount0Min, amount1Min, deadline } = params;
+  const extraData = encodeAbiParameters(
+    parseAbiParameters("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? maxUint256]
+  );
+  return encodeFunctionData({
+    abi: PeripheryPoolABI2,
+    functionName: "increaseLiquidity",
+    args: [tokenId, amount0, amount1, extraData]
+  });
+}
+function encodeDecreaseLiquidity(params) {
+  const { tokenId, liquidityAmount, amount0Min, amount1Min, deadline } = params;
+  const extraData = encodeAbiParameters(
+    parseAbiParameters("uint256,uint256,uint256"),
+    [amount0Min ?? 0n, amount1Min ?? 0n, deadline ?? maxUint256]
+  );
+  return encodeFunctionData({
+    abi: PeripheryPoolABI2,
+    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
+import { AmmCore as AmmCore3 } from "@skate-org/amm-core-v2";
+import { AmmApi } from "@skate-org/amm-api-v2";
+var SkateAmm = class {
+  env;
+  core;
+  api;
+  vm;
+  quote;
+  actions;
+  pools;
+  constructor(env) {
+    this.env = env;
+    this.core = new AmmCore3(env);
+    this.api = new 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
 import { decodeEventLog } from "viem";
 import { KernelEventEmitterABI } from "@skate-org/amm-bindings";
@@ -670,10 +1059,17 @@ function watchPeripheryEvents(client, address, opts) {
   });
 }
 export {
+  AmmEvm,
   EvmReadError,
   EvmWriteError,
   KERNEL_EVENT_NAMES,
   PERIPHERY_EVENT_NAMES,
+  SkateAmm,
+  buildBurn,
+  buildDecreaseLiquidity,
+  buildIncreaseLiquidity,
+  buildMint,
+  buildSwap,
   computePositionAmounts,
   createDevConfig,
   decodeTickBitmapWord,
@@ -682,6 +1078,7 @@ export {
   megaethChain,
   parseKernelEventLog,
   parsePeripheryEventLog,
+  readKernelBalances,
   readPeripheryPool,
   readPool,
   readPosition,