boing-sdk 0.3.0

package/dist/indexerGaps.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Merge pruned / missing height ranges and compute safe contiguous cursor advancement.
+ * Pair with {@link summarizeIndexerFetchGaps} and `onMissingBlock: 'omit'` fetches.
+ */
+import type { IndexerFetchGapSummary } from './indexerBatch.js';
+/** Inclusive block height range (same shape as {@link IndexerFetchGapSummary.missingHeightRangesInclusive}). */
+export interface InclusiveHeightRange {
+    fromHeight: number;
+    toHeight: number;
+}
+/**
+ * Sort and merge overlapping or adjacent inclusive ranges into a minimal cover.
+ */
+export declare function mergeInclusiveHeightRanges(ranges: readonly InclusiveHeightRange[]): InclusiveHeightRange[];
+/** Union of two range lists (merge + normalize). */
+export declare function unionInclusiveHeightRanges(a: readonly InclusiveHeightRange[], b: readonly InclusiveHeightRange[]): InclusiveHeightRange[];
+/**
+ * Remove heights **`indexed`** from each stored gap (e.g. after archive backfill). Input gaps are normalized
+ * (merged) first; the result is merged again so adjacent remnants stay minimal.
+ */
+export declare function subtractInclusiveRangeFromRanges(indexed: InclusiveHeightRange, gaps: readonly InclusiveHeightRange[]): InclusiveHeightRange[];
+/** One row matching **`tools/observer-indexer-schema.sql`** → **`block_height_gaps`**. */
+export interface BlockHeightGapInsertRow {
+    chain_id: string;
+    from_height: number;
+    to_height: number;
+    reason: string;
+    recorded_at: number;
+}
+/**
+ * Normalized **`block_height_gaps`** rows for parameterized INSERT (one row per merged contiguous run).
+ */
+export declare function blockHeightGapRowsForInsert(input: {
+    chainId: string;
+    ranges: readonly InclusiveHeightRange[];
+    reason?: string;
+    recordedAtSec?: number;
+}): BlockHeightGapInsertRow[];
+/**
+ * After fetching `[lastIndexedHeight + 1, …]` with omissions, highest height that remains **contiguous**
+ * from `lastIndexedHeight` (i.e. you may set `ingest_cursor.last_committed_height` here without holes).
+ *
+ * - Full success (no omissions): `requestedToHeight`.
+ * - Gap at the start of the tick: `lastIndexedHeight` (no forward progress on the contiguous cursor).
+ * - Gap in the middle/end: `lastContiguousFromStart` from the summary (may be below `requestedToHeight`).
+ *
+ * @throws if `summary.requestedFromHeight !== lastIndexedHeight + 1`
+ */
+export declare function nextContiguousIndexedHeightAfterOmittedFetch(lastIndexedHeight: number, summary: IndexerFetchGapSummary): number;
+//# sourceMappingURL=indexerGaps.d.ts.map

package/dist/indexerGaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexerGaps.d.ts","sourceRoot":"","sources":["../src/indexerGaps.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,gHAAgH;AAChH,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAcD;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,GAAG,oBAAoB,EAAE,CAmB1G;AAED,oDAAoD;AACpD,wBAAgB,0BAA0B,CACxC,CAAC,EAAE,SAAS,oBAAoB,EAAE,EAClC,CAAC,EAAE,SAAS,oBAAoB,EAAE,GACjC,oBAAoB,EAAE,CAExB;AAgBD;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,oBAAoB,EAC7B,IAAI,EAAE,SAAS,oBAAoB,EAAE,GACpC,oBAAoB,EAAE,CASxB;AAED,0FAA0F;AAC1F,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,uBAAuB,EAAE,CAW5B;AAOD;;;;;;;;;GASG;AACH,wBAAgB,4CAA4C,CAC1D,iBAAiB,EAAE,MAAM,EACzB,OAAO,EAAE,sBAAsB,GAC9B,MAAM,CAeR"}

package/dist/indexerGaps.js

@@ -0,0 +1,117 @@
+/**
+ * Merge pruned / missing height ranges and compute safe contiguous cursor advancement.
+ * Pair with {@link summarizeIndexerFetchGaps} and `onMissingBlock: 'omit'` fetches.
+ */
+function assertInclusiveRange(r, label) {
+    if (!Number.isInteger(r.fromHeight) || !Number.isInteger(r.toHeight)) {
+        throw new TypeError(`${label}: fromHeight and toHeight must be integers`);
+    }
+    if (r.fromHeight < 0 || r.toHeight < 0) {
+        throw new RangeError(`${label}: heights must be >= 0`);
+    }
+    if (r.fromHeight > r.toHeight) {
+        throw new RangeError(`${label}: fromHeight must be <= toHeight`);
+    }
+}
+/**
+ * Sort and merge overlapping or adjacent inclusive ranges into a minimal cover.
+ */
+export function mergeInclusiveHeightRanges(ranges) {
+    if (ranges.length === 0)
+        return [];
+    for (let i = 0; i < ranges.length; i++) {
+        assertInclusiveRange(ranges[i], `ranges[${i}]`);
+    }
+    const sorted = [...ranges].sort((a, b) => a.fromHeight - b.fromHeight);
+    const out = [];
+    let cur = { ...sorted[0] };
+    for (let i = 1; i < sorted.length; i++) {
+        const r = sorted[i];
+        if (r.fromHeight > cur.toHeight + 1) {
+            out.push(cur);
+            cur = { ...r };
+        }
+        else {
+            cur.toHeight = Math.max(cur.toHeight, r.toHeight);
+        }
+    }
+    out.push(cur);
+    return out;
+}
+/** Union of two range lists (merge + normalize). */
+export function unionInclusiveHeightRanges(a, b) {
+    return mergeInclusiveHeightRanges([...a, ...b]);
+}
+function subtractOneGapByIndexedRange(indexed, gap) {
+    if (indexed.toHeight < gap.fromHeight || indexed.fromHeight > gap.toHeight) {
+        return [{ ...gap }];
+    }
+    const out = [];
+    if (gap.fromHeight < indexed.fromHeight) {
+        out.push({ fromHeight: gap.fromHeight, toHeight: indexed.fromHeight - 1 });
+    }
+    if (indexed.toHeight < gap.toHeight) {
+        out.push({ fromHeight: indexed.toHeight + 1, toHeight: gap.toHeight });
+    }
+    return out;
+}
+/**
+ * Remove heights **`indexed`** from each stored gap (e.g. after archive backfill). Input gaps are normalized
+ * (merged) first; the result is merged again so adjacent remnants stay minimal.
+ */
+export function subtractInclusiveRangeFromRanges(indexed, gaps) {
+    assertInclusiveRange(indexed, 'indexed');
+    if (gaps.length === 0)
+        return [];
+    const normalized = mergeInclusiveHeightRanges(gaps);
+    const pieces = [];
+    for (const g of normalized) {
+        pieces.push(...subtractOneGapByIndexedRange(indexed, g));
+    }
+    return mergeInclusiveHeightRanges(pieces);
+}
+/**
+ * Normalized **`block_height_gaps`** rows for parameterized INSERT (one row per merged contiguous run).
+ */
+export function blockHeightGapRowsForInsert(input) {
+    const reason = input.reason ?? 'pruned';
+    const recorded_at = input.recordedAtSec ?? Math.floor(Date.now() / 1000);
+    const merged = mergeInclusiveHeightRanges(input.ranges);
+    return merged.map((r) => ({
+        chain_id: input.chainId,
+        from_height: r.fromHeight,
+        to_height: r.toHeight,
+        reason,
+        recorded_at,
+    }));
+}
+function assertIndexerCursor(name, h) {
+    if (!Number.isInteger(h))
+        throw new TypeError(`${name} must be an integer`);
+    if (h < -1)
+        throw new RangeError(`${name} must be >= -1`);
+}
+/**
+ * After fetching `[lastIndexedHeight + 1, …]` with omissions, highest height that remains **contiguous**
+ * from `lastIndexedHeight` (i.e. you may set `ingest_cursor.last_committed_height` here without holes).
+ *
+ * - Full success (no omissions): `requestedToHeight`.
+ * - Gap at the start of the tick: `lastIndexedHeight` (no forward progress on the contiguous cursor).
+ * - Gap in the middle/end: `lastContiguousFromStart` from the summary (may be below `requestedToHeight`).
+ *
+ * @throws if `summary.requestedFromHeight !== lastIndexedHeight + 1`
+ */
+export function nextContiguousIndexedHeightAfterOmittedFetch(lastIndexedHeight, summary) {
+    assertIndexerCursor('lastIndexedHeight', lastIndexedHeight);
+    const next = lastIndexedHeight + 1;
+    if (summary.requestedFromHeight !== next) {
+        throw new RangeError(`summary.requestedFromHeight (${summary.requestedFromHeight}) must equal lastIndexedHeight + 1 (${next})`);
+    }
+    if (summary.omittedHeights.length === 0) {
+        return summary.requestedToHeight;
+    }
+    if (summary.lastContiguousFromStart === null) {
+        return lastIndexedHeight;
+    }
+    return summary.lastContiguousFromStart;
+}

package/dist/indexerSync.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Finality / tip helpers for indexers using `boing_getSyncState`.
+ * See `docs/RPC-API-SPEC.md` — today `head_height` and `finalized_height` match; they may diverge later.
+ */
+import type { BoingClient } from './client.js';
+export interface IndexerChainTips {
+    headHeight: number;
+    finalizedHeight: number;
+    /**
+     * Inclusive upper bound for **durable** indexing: min(head, finalized).
+     * Prefer indexing only through this height until the node exposes lagging finalized semantics.
+     */
+    durableIndexThrough: number;
+    /** Tip block hash (32-byte hex). */
+    latestBlockHash: string;
+}
+/**
+ * Read committed tip + finalized fields from the node (single RPC).
+ */
+export declare function getIndexerChainTips(client: BoingClient): Promise<IndexerChainTips>;
+/**
+ * Clamp an inclusive `[fromHeight, toHeight]` so `toHeight` does not exceed `durableIndexThrough`.
+ * Returns `null` if the range is empty after clamping or if `fromHeight > toHeight`.
+ */
+export declare function clampIndexerHeightRange(fromHeight: number, toHeight: number, durableIndexThrough: number): {
+    fromHeight: number;
+    toHeight: number;
+} | null;
+/** How {@link planIndexerChainTipsWithFallback} obtained {@link IndexerChainTips}. */
+export type IndexerTipsSource = 'sync_state' | 'chain_height';
+export interface PlanIndexerCatchUpOptions {
+    /**
+     * Cap one tick to at most this many block heights (inclusive count).
+     * When unset, the planned range runs through the clamped durable tip.
+     */
+    maxBlocksPerTick?: number;
+}
+/** Result of {@link planIndexerCatchUp}: durable range `[fromHeight, toHeight]` to fetch next. */
+export interface IndexerCatchUpPlan {
+    tips: IndexerChainTips;
+    tipsSource: IndexerTipsSource;
+    fromHeight: number;
+    toHeight: number;
+}
+/**
+ * Like {@link getIndexerChainTips}, but when **`boing_getSyncState`** returns **-32601**,
+ * builds tips from **`boing_chainHeight`** + **`boing_getBlockByHeight(tip, false)`** (needs block **`hash`**).
+ */
+export declare function planIndexerChainTipsWithFallback(client: BoingClient): Promise<{
+    tips: IndexerChainTips;
+    tipsSource: IndexerTipsSource;
+}>;
+/**
+ * One ingestion tick: load chain tips (with **`getSyncState`** fallback), then
+ * **`clampIndexerHeightRange(lastIndexedHeight + 1, headHeight, durableIndexThrough)`**.
+ * Returns **`null`** when there is nothing to index yet.
+ *
+ * @param lastIndexedHeight — height you have fully persisted (**`-1`** before genesis).
+ */
+export declare function planIndexerCatchUp(client: BoingClient, lastIndexedHeight: number, options?: PlanIndexerCatchUpOptions): Promise<IndexerCatchUpPlan | null>;
+//# sourceMappingURL=indexerSync.d.ts.map

package/dist/indexerSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexerSync.d.ts","sourceRoot":"","sources":["../src/indexerSync.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oCAAoC;IACpC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAUxF;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,MAAM,GAC1B;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQjD;AAYD,sFAAsF;AACtF,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,cAAc,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,kGAAkG;AAClG,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE,CAAC,CAsBpE;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,WAAW,EACnB,iBAAiB,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAoBpC"}

package/dist/indexerSync.js

@@ -0,0 +1,100 @@
+/**
+ * Finality / tip helpers for indexers using `boing_getSyncState`.
+ * See `docs/RPC-API-SPEC.md` — today `head_height` and `finalized_height` match; they may diverge later.
+ */
+import { isBoingRpcMethodNotFound } from './errors.js';
+/**
+ * Read committed tip + finalized fields from the node (single RPC).
+ */
+export async function getIndexerChainTips(client) {
+    const s = await client.getSyncState();
+    const headHeight = s.head_height;
+    const finalizedHeight = s.finalized_height;
+    return {
+        headHeight,
+        finalizedHeight,
+        durableIndexThrough: Math.min(headHeight, finalizedHeight),
+        latestBlockHash: s.latest_block_hash,
+    };
+}
+/**
+ * Clamp an inclusive `[fromHeight, toHeight]` so `toHeight` does not exceed `durableIndexThrough`.
+ * Returns `null` if the range is empty after clamping or if `fromHeight > toHeight`.
+ */
+export function clampIndexerHeightRange(fromHeight, toHeight, durableIndexThrough) {
+    assertNonNegInt('fromHeight', fromHeight);
+    assertNonNegInt('toHeight', toHeight);
+    assertNonNegInt('durableIndexThrough', durableIndexThrough);
+    if (fromHeight > toHeight)
+        return null;
+    const cappedTo = Math.min(toHeight, durableIndexThrough);
+    if (fromHeight > cappedTo)
+        return null;
+    return { fromHeight, toHeight: cappedTo };
+}
+function assertNonNegInt(name, h) {
+    if (!Number.isInteger(h))
+        throw new TypeError(`${name} must be an integer`);
+    if (h < 0)
+        throw new RangeError(`${name} must be >= 0`);
+}
+function assertIndexerCursor(name, h) {
+    if (!Number.isInteger(h))
+        throw new TypeError(`${name} must be an integer`);
+    if (h < -1)
+        throw new RangeError(`${name} must be >= -1 (use -1 before genesis)`);
+}
+/**
+ * Like {@link getIndexerChainTips}, but when **`boing_getSyncState`** returns **-32601**,
+ * builds tips from **`boing_chainHeight`** + **`boing_getBlockByHeight(tip, false)`** (needs block **`hash`**).
+ */
+export async function planIndexerChainTipsWithFallback(client) {
+    try {
+        const tips = await getIndexerChainTips(client);
+        return { tips, tipsSource: 'sync_state' };
+    }
+    catch (e) {
+        if (!isBoingRpcMethodNotFound(e))
+            throw e;
+        const height = await client.chainHeight();
+        const head = await client.getBlockByHeight(height, false);
+        const hash = head?.hash;
+        if (hash == null || !/^0x[0-9a-f]{64}$/i.test(hash)) {
+            throw new Error('Indexer fallback: boing_getSyncState missing and tip block has no hash — use a current boing-node RPC');
+        }
+        const tips = {
+            headHeight: height,
+            finalizedHeight: height,
+            durableIndexThrough: height,
+            latestBlockHash: hash,
+        };
+        return { tips, tipsSource: 'chain_height' };
+    }
+}
+/**
+ * One ingestion tick: load chain tips (with **`getSyncState`** fallback), then
+ * **`clampIndexerHeightRange(lastIndexedHeight + 1, headHeight, durableIndexThrough)`**.
+ * Returns **`null`** when there is nothing to index yet.
+ *
+ * @param lastIndexedHeight — height you have fully persisted (**`-1`** before genesis).
+ */
+export async function planIndexerCatchUp(client, lastIndexedHeight, options) {
+    assertIndexerCursor('lastIndexedHeight', lastIndexedHeight);
+    const { tips, tipsSource } = await planIndexerChainTipsWithFallback(client);
+    const nextFrom = lastIndexedHeight + 1;
+    const clamped = clampIndexerHeightRange(nextFrom, tips.headHeight, tips.durableIndexThrough);
+    if (clamped == null)
+        return null;
+    let { fromHeight, toHeight } = clamped;
+    const cap = options?.maxBlocksPerTick;
+    if (cap != null) {
+        if (!Number.isInteger(cap) || cap < 1) {
+            throw new RangeError('maxBlocksPerTick must be an integer >= 1');
+        }
+        const span = toHeight - fromHeight + 1;
+        if (span > cap) {
+            toHeight = fromHeight + cap - 1;
+        }
+    }
+    return { tips, tipsSource, fromHeight, toHeight };
+}

package/dist/nativeAmm.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Native constant-product pool calldata (Boing VM). See `docs/NATIVE-AMM-CALLDATA.md`.
+ * Reserves and amounts should stay ≤ `Number.MAX_SAFE_INTEGER` / u64 range for VM `Mul` parity.
+ */
+/** `swap` selector (low byte of word0). */
+export declare const SELECTOR_NATIVE_AMM_SWAP = 16;
+/** `add_liquidity` selector. */
+export declare const SELECTOR_NATIVE_AMM_ADD_LIQUIDITY = 17;
+/** `remove_liquidity` selector (LP burn + pro-rata withdrawal). */
+export declare const SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY = 18;
+/** **v2 pool:** one-time `set_tokens(token_a, token_b)`. */
+export declare const SELECTOR_NATIVE_AMM_SET_TOKENS = 19;
+/** **v3/v4 pool:** `set_swap_fee_bps(fee)` — **64-byte** calldata; only when **total LP == 0**; **`1 ≤ fee ≤ 10_000`**. */
+export declare const SELECTOR_NATIVE_AMM_SET_SWAP_FEE_BPS = 20;
+/** **v5 pool:** `swap_to` — like `swap` plus **word4** = output recipient (**160-byte** calldata). */
+export declare const SELECTOR_NATIVE_AMM_SWAP_TO = 21;
+/** **v5 pool:** `remove_liquidity_to` — like `remove_liquidity` plus **recipient_a** / **recipient_b** (**192-byte** calldata). */
+export declare const SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY_TO = 22;
+/** Swap fee in basis points on **output** (matches `native_amm::NATIVE_CP_SWAP_FEE_BPS`). */
+export declare const NATIVE_CP_SWAP_FEE_BPS = 30;
+/** Build 32-byte `Log2` **topic0** (UTF-8 ASCII + zero pad), matching `native_amm` constants. */
+export declare function nativeAmmLogTopic0Utf8(ascii: string): Uint8Array;
+/** `Log2` topic0 hex for a successful **`swap`** (see `NATIVE-AMM-CALLDATA.md` § Logs). */
+export declare const NATIVE_AMM_TOPIC_SWAP_HEX: string;
+/** `Log2` topic0 hex for **`add_liquidity`**. */
+export declare const NATIVE_AMM_TOPIC_ADD_LIQUIDITY_HEX: string;
+/** `Log2` topic0 hex for **`remove_liquidity`**. */
+export declare const NATIVE_AMM_TOPIC_REMOVE_LIQUIDITY_HEX: string;
+/** 128-byte `swap` calldata: direction 0 = A→B, 1 = B→A. */
+export declare function encodeNativeAmmSwapCalldata(direction: bigint, amountIn: bigint, minOut: bigint): Uint8Array;
+/** **160-byte** `swap_to` calldata (v5 pool): explicit **output recipient** for token `transfer`. */
+export declare function encodeNativeAmmSwapToCalldata(direction: bigint, amountIn: bigint, minOut: bigint, recipientHex32: string): Uint8Array;
+/**
+ * 128-byte `add_liquidity` calldata. On success the pool **returns** **32** bytes: LP minted in this
+ * call as **u128** in the **low 16 bytes** of the word (big-endian word; value in bytes 16..32).
+ */
+export declare function encodeNativeAmmAddLiquidityCalldata(amountA: bigint, amountB: bigint, minLiquidity: bigint): Uint8Array;
+/** 128-byte `remove_liquidity` calldata. */
+export declare function encodeNativeAmmRemoveLiquidityCalldata(liquidityBurn: bigint, minA: bigint, minB: bigint): Uint8Array;
+/** **192-byte** `remove_liquidity_to` (v5 pool): explicit **recipient_a** / **recipient_b** for reference-token `transfer`. */
+export declare function encodeNativeAmmRemoveLiquidityToCalldata(liquidityBurn: bigint, minA: bigint, minB: bigint, recipientAHex32: string, recipientBHex32: string): Uint8Array;
+/** **v2:** 96-byte `set_tokens` — each id is 32-byte account hex (`0x` + 64 hex). Use `0x` + 64 zeros for “no token” on that side. */
+export declare function encodeNativeAmmSetTokensCalldata(tokenAHex32: string, tokenBHex32: string): Uint8Array;
+/** **v3/v4:** 64-byte `set_swap_fee_bps` calldata (`native_amm::encode_set_swap_fee_bps_calldata`). */
+export declare function encodeNativeAmmSetSwapFeeBpsCalldata(feeBps: bigint): Uint8Array;
+export declare function encodeNativeAmmSwapCalldataHex(direction: bigint, amountIn: bigint, minOut: bigint): string;
+export declare function encodeNativeAmmSwapToCalldataHex(direction: bigint, amountIn: bigint, minOut: bigint, recipientHex32: string): string;
+export declare function encodeNativeAmmAddLiquidityCalldataHex(amountA: bigint, amountB: bigint, minLiquidity?: bigint): string;
+export declare function encodeNativeAmmRemoveLiquidityCalldataHex(liquidityBurn: bigint, minA: bigint, minB: bigint): string;
+export declare function encodeNativeAmmRemoveLiquidityToCalldataHex(liquidityBurn: bigint, minA: bigint, minB: bigint, recipientAHex32: string, recipientBHex32: string): string;
+export declare function encodeNativeAmmSetTokensCalldataHex(tokenAHex32: string, tokenBHex32: string): string;
+export declare function encodeNativeAmmSetSwapFeeBpsCalldataHex(feeBps: bigint): string;
+/** Raw CP step (no swap fee): Δout = ⌊ r_out · Δin / (r_in + Δin) ⌋. */
+export declare function constantProductAmountOutNoFee(reserveIn: bigint, reserveOut: bigint, amountIn: bigint): bigint;
+/**
+ * Amount out after an explicit **output-side** fee in basis points (`native_amm::constant_product_amount_out_after_fee_with_bps`).
+ * **`feeBps`** must be **`0`…`10000`** (inclusive). For **v3/v4** pools, if storage at `swap_fee_bps_key` reads **`0`**, treat as **`NATIVE_CP_SWAP_FEE_BPS`** before quoting.
+ */
+export declare function constantProductAmountOutWithFeeBps(reserveIn: bigint, reserveOut: bigint, amountIn: bigint, feeBps: bigint): bigint;
+/**
+ * Amount out after pool swap fee (output-side): same as **`constantProductAmountOutWithFeeBps`** with **`NATIVE_CP_SWAP_FEE_BPS`**.
+ */
+export declare function constantProductAmountOut(reserveIn: bigint, reserveOut: bigint, amountIn: bigint): bigint;
+//# sourceMappingURL=nativeAmm.d.ts.map

package/dist/nativeAmm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeAmm.d.ts","sourceRoot":"","sources":["../src/nativeAmm.ts"],"names":[],"mappings":"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"}

package/dist/nativeAmm.js

@@ -0,0 +1,174 @@
+/**
+ * Native constant-product pool calldata (Boing VM). See `docs/NATIVE-AMM-CALLDATA.md`.
+ * Reserves and amounts should stay ≤ `Number.MAX_SAFE_INTEGER` / u64 range for VM `Mul` parity.
+ */
+import { bytesToHex, hexToBytes, validateHex32 } from './hex.js';
+/** `swap` selector (low byte of word0). */
+export const SELECTOR_NATIVE_AMM_SWAP = 0x10;
+/** `add_liquidity` selector. */
+export const SELECTOR_NATIVE_AMM_ADD_LIQUIDITY = 0x11;
+/** `remove_liquidity` selector (LP burn + pro-rata withdrawal). */
+export const SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY = 0x12;
+/** **v2 pool:** one-time `set_tokens(token_a, token_b)`. */
+export const SELECTOR_NATIVE_AMM_SET_TOKENS = 0x13;
+/** **v3/v4 pool:** `set_swap_fee_bps(fee)` — **64-byte** calldata; only when **total LP == 0**; **`1 ≤ fee ≤ 10_000`**. */
+export const SELECTOR_NATIVE_AMM_SET_SWAP_FEE_BPS = 0x14;
+/** **v5 pool:** `swap_to` — like `swap` plus **word4** = output recipient (**160-byte** calldata). */
+export const SELECTOR_NATIVE_AMM_SWAP_TO = 0x15;
+/** **v5 pool:** `remove_liquidity_to` — like `remove_liquidity` plus **recipient_a** / **recipient_b** (**192-byte** calldata). */
+export const SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY_TO = 0x16;
+/** Swap fee in basis points on **output** (matches `native_amm::NATIVE_CP_SWAP_FEE_BPS`). */
+export const NATIVE_CP_SWAP_FEE_BPS = 30;
+/** Build 32-byte `Log2` **topic0** (UTF-8 ASCII + zero pad), matching `native_amm` constants. */
+export function nativeAmmLogTopic0Utf8(ascii) {
+    const u8 = new Uint8Array(32);
+    const enc = new TextEncoder().encode(ascii);
+    if (enc.length > 32) {
+        throw new RangeError('native AMM topic0 label too long');
+    }
+    u8.set(enc);
+    return u8;
+}
+/** `Log2` topic0 hex for a successful **`swap`** (see `NATIVE-AMM-CALLDATA.md` § Logs). */
+export const NATIVE_AMM_TOPIC_SWAP_HEX = bytesToHex(nativeAmmLogTopic0Utf8('BOING_NATIVEAMM_SWAP_V1'));
+/** `Log2` topic0 hex for **`add_liquidity`**. */
+export const NATIVE_AMM_TOPIC_ADD_LIQUIDITY_HEX = bytesToHex(nativeAmmLogTopic0Utf8('BOING_NATIVEAMM_ADDLP_V1'));
+/** `Log2` topic0 hex for **`remove_liquidity`**. */
+export const NATIVE_AMM_TOPIC_REMOVE_LIQUIDITY_HEX = bytesToHex(nativeAmmLogTopic0Utf8('BOING_NATIVEAMM_RMLP_V1'));
+function selectorWord(selector) {
+    const w = new Uint8Array(32);
+    w[31] = selector & 0xff;
+    return w;
+}
+function amountWord(amount) {
+    const w = new Uint8Array(32);
+    if (amount < 0n || amount > (1n << 128n) - 1n) {
+        throw new RangeError('amount must fit in u128');
+    }
+    const be = new Uint8Array(16);
+    let x = amount;
+    for (let i = 15; i >= 0; i--) {
+        be[i] = Number(x & 0xffn);
+        x >>= 8n;
+    }
+    w.set(be, 16);
+    return w;
+}
+/** 128-byte `swap` calldata: direction 0 = A→B, 1 = B→A. */
+export function encodeNativeAmmSwapCalldata(direction, amountIn, minOut) {
+    const out = new Uint8Array(128);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_SWAP), 0);
+    out.set(amountWord(direction), 32);
+    out.set(amountWord(amountIn), 64);
+    out.set(amountWord(minOut), 96);
+    return out;
+}
+/** **160-byte** `swap_to` calldata (v5 pool): explicit **output recipient** for token `transfer`. */
+export function encodeNativeAmmSwapToCalldata(direction, amountIn, minOut, recipientHex32) {
+    const out = new Uint8Array(160);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_SWAP_TO), 0);
+    out.set(amountWord(direction), 32);
+    out.set(amountWord(amountIn), 64);
+    out.set(amountWord(minOut), 96);
+    out.set(hexToBytes(validateHex32(recipientHex32)), 128);
+    return out;
+}
+/**
+ * 128-byte `add_liquidity` calldata. On success the pool **returns** **32** bytes: LP minted in this
+ * call as **u128** in the **low 16 bytes** of the word (big-endian word; value in bytes 16..32).
+ */
+export function encodeNativeAmmAddLiquidityCalldata(amountA, amountB, minLiquidity) {
+    const out = new Uint8Array(128);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_ADD_LIQUIDITY), 0);
+    out.set(amountWord(amountA), 32);
+    out.set(amountWord(amountB), 64);
+    out.set(amountWord(minLiquidity), 96);
+    return out;
+}
+/** 128-byte `remove_liquidity` calldata. */
+export function encodeNativeAmmRemoveLiquidityCalldata(liquidityBurn, minA, minB) {
+    const out = new Uint8Array(128);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY), 0);
+    out.set(amountWord(liquidityBurn), 32);
+    out.set(amountWord(minA), 64);
+    out.set(amountWord(minB), 96);
+    return out;
+}
+/** **192-byte** `remove_liquidity_to` (v5 pool): explicit **recipient_a** / **recipient_b** for reference-token `transfer`. */
+export function encodeNativeAmmRemoveLiquidityToCalldata(liquidityBurn, minA, minB, recipientAHex32, recipientBHex32) {
+    const out = new Uint8Array(192);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_REMOVE_LIQUIDITY_TO), 0);
+    out.set(amountWord(liquidityBurn), 32);
+    out.set(amountWord(minA), 64);
+    out.set(amountWord(minB), 96);
+    out.set(hexToBytes(validateHex32(recipientAHex32)), 128);
+    out.set(hexToBytes(validateHex32(recipientBHex32)), 160);
+    return out;
+}
+/** **v2:** 96-byte `set_tokens` — each id is 32-byte account hex (`0x` + 64 hex). Use `0x` + 64 zeros for “no token” on that side. */
+export function encodeNativeAmmSetTokensCalldata(tokenAHex32, tokenBHex32) {
+    const out = new Uint8Array(96);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_SET_TOKENS), 0);
+    out.set(hexToBytes(validateHex32(tokenAHex32)), 32);
+    out.set(hexToBytes(validateHex32(tokenBHex32)), 64);
+    return out;
+}
+/** **v3/v4:** 64-byte `set_swap_fee_bps` calldata (`native_amm::encode_set_swap_fee_bps_calldata`). */
+export function encodeNativeAmmSetSwapFeeBpsCalldata(feeBps) {
+    if (feeBps < 1n || feeBps > 10000n) {
+        throw new RangeError('feeBps must satisfy 1 <= feeBps <= 10000');
+    }
+    const out = new Uint8Array(64);
+    out.set(selectorWord(SELECTOR_NATIVE_AMM_SET_SWAP_FEE_BPS), 0);
+    out.set(amountWord(feeBps), 32);
+    return out;
+}
+export function encodeNativeAmmSwapCalldataHex(direction, amountIn, minOut) {
+    return bytesToHex(encodeNativeAmmSwapCalldata(direction, amountIn, minOut));
+}
+export function encodeNativeAmmSwapToCalldataHex(direction, amountIn, minOut, recipientHex32) {
+    return bytesToHex(encodeNativeAmmSwapToCalldata(direction, amountIn, minOut, recipientHex32));
+}
+export function encodeNativeAmmAddLiquidityCalldataHex(amountA, amountB, minLiquidity = 0n) {
+    return bytesToHex(encodeNativeAmmAddLiquidityCalldata(amountA, amountB, minLiquidity));
+}
+export function encodeNativeAmmRemoveLiquidityCalldataHex(liquidityBurn, minA, minB) {
+    return bytesToHex(encodeNativeAmmRemoveLiquidityCalldata(liquidityBurn, minA, minB));
+}
+export function encodeNativeAmmRemoveLiquidityToCalldataHex(liquidityBurn, minA, minB, recipientAHex32, recipientBHex32) {
+    return bytesToHex(encodeNativeAmmRemoveLiquidityToCalldata(liquidityBurn, minA, minB, recipientAHex32, recipientBHex32));
+}
+export function encodeNativeAmmSetTokensCalldataHex(tokenAHex32, tokenBHex32) {
+    return bytesToHex(encodeNativeAmmSetTokensCalldata(tokenAHex32, tokenBHex32));
+}
+export function encodeNativeAmmSetSwapFeeBpsCalldataHex(feeBps) {
+    return bytesToHex(encodeNativeAmmSetSwapFeeBpsCalldata(feeBps));
+}
+/** Raw CP step (no swap fee): Δout = ⌊ r_out · Δin / (r_in + Δin) ⌋. */
+export function constantProductAmountOutNoFee(reserveIn, reserveOut, amountIn) {
+    if (reserveIn < 0n || reserveOut < 0n || amountIn < 0n) {
+        throw new RangeError('reserves and amountIn must be non-negative');
+    }
+    const denom = reserveIn + amountIn;
+    if (denom === 0n)
+        return 0n;
+    return (reserveOut * amountIn) / denom;
+}
+/**
+ * Amount out after an explicit **output-side** fee in basis points (`native_amm::constant_product_amount_out_after_fee_with_bps`).
+ * **`feeBps`** must be **`0`…`10000`** (inclusive). For **v3/v4** pools, if storage at `swap_fee_bps_key` reads **`0`**, treat as **`NATIVE_CP_SWAP_FEE_BPS`** before quoting.
+ */
+export function constantProductAmountOutWithFeeBps(reserveIn, reserveOut, amountIn, feeBps) {
+    if (feeBps < 0n || feeBps > 10000n) {
+        throw new RangeError('feeBps must satisfy 0 <= feeBps <= 10000');
+    }
+    const dy = constantProductAmountOutNoFee(reserveIn, reserveOut, amountIn);
+    const keep = 10000n - feeBps;
+    return (dy * keep) / 10000n;
+}
+/**
+ * Amount out after pool swap fee (output-side): same as **`constantProductAmountOutWithFeeBps`** with **`NATIVE_CP_SWAP_FEE_BPS`**.
+ */
+export function constantProductAmountOut(reserveIn, reserveOut, amountIn) {
+    return constantProductAmountOutWithFeeBps(reserveIn, reserveOut, amountIn, BigInt(NATIVE_CP_SWAP_FEE_BPS));
+}

package/dist/nativeAmmLogs.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Parse native constant-product pool **`Log2`** rows (`topic0` + caller `topic1` + 96-byte `data`).
+ * Matches `native_amm` emission and `docs/NATIVE-AMM-CALLDATA.md` § Logs.
+ */
+import type { ExecutionLog, ExecutionReceipt, RpcLogEntry } from './types.js';
+/** Discriminant for a parsed native AMM `Log2` event. */
+export type NativeAmmLog2Kind = 'swap' | 'addLiquidity' | 'removeLiquidity';
+export type NativeAmmLog2Event = {
+    kind: 'swap';
+    callerHex: string;
+    /** Calldata-style direction: `0` = A→B, `1` = B→A. */
+    direction: bigint;
+    amountIn: bigint;
+    amountOutAfterFee: bigint;
+} | {
+    kind: 'addLiquidity';
+    callerHex: string;
+    amountA: bigint;
+    amountB: bigint;
+    lpMinted: bigint;
+} | {
+    kind: 'removeLiquidity';
+    callerHex: string;
+    liquidityBurned: bigint;
+    amountAOut: bigint;
+    amountBOut: bigint;
+};
+/** `tryParseNativeAmmRpcLogEntry` result: parsed fields plus RPC placement. */
+export type NativeAmmRpcLogParsed = NativeAmmLog2Event & Pick<RpcLogEntry, 'block_height' | 'tx_index' | 'tx_id' | 'log_index' | 'address'>;
+/** True if `topic` (any casing / optional `0x`) is one of the three native AMM `Log2` topic0 values. */
+export declare function isNativeAmmLog2Topic0(topic: string): boolean;
+/**
+ * True if `log` looks like a native AMM `Log2` (two topics, known topic0). Does not validate `data`.
+ */
+export declare function isNativeAmmLog2Shape(log: Pick<ExecutionLog, 'topics'>): boolean;
+/**
+ * Parse one receipt / RPC log into a typed event, or `null` if shape or `data` does not match.
+ */
+export declare function tryParseNativeAmmLog2(log: Pick<ExecutionLog, 'topics' | 'data'>): NativeAmmLog2Event | null;
+export declare function tryParseNativeAmmRpcLogEntry(entry: RpcLogEntry): NativeAmmRpcLogParsed | null;
+/** Keep only `RpcLogEntry` rows that parse as native AMM `Log2`, with placement fields attached. */
+export declare function filterMapNativeAmmRpcLogs(entries: readonly RpcLogEntry[]): NativeAmmRpcLogParsed[];
+/** All successfully parsed native AMM logs in one receipt (in log order). */
+export declare function collectNativeAmmLog2FromReceipt(receipt: ExecutionReceipt): Array<{
+    logIndex: number;
+    event: NativeAmmLog2Event;
+}>;
+//# sourceMappingURL=nativeAmmLogs.d.ts.map

package/dist/nativeAmmLogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeAmmLogs.d.ts","sourceRoot":"","sources":["../src/nativeAmmLogs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAM9E,yDAAyD;AACzD,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAE5E,MAAM,MAAM,kBAAkB,GAC1B;IACE,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GACD;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,GACD;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEN,+EAA+E;AAC/E,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,GACpD,IAAI,CAAC,WAAW,EAAE,cAAc,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,CAAC,CAAC;AASrF,wGAAwG;AACxG,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAM5D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,GAAG,OAAO,CAG/E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,MAAM,CAAC,GAAG,kBAAkB,GAAG,IAAI,CAsC3G;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,WAAW,GAAG,qBAAqB,GAAG,IAAI,CAW7F;AAED,oGAAoG;AACpG,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,qBAAqB,EAAE,CAOlG;AAED,6EAA6E;AAC7E,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gBAAgB,GACxB,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAOxD"}