boing-sdk 0.3.0

package/dist/nativeDexLedgerRouter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Ledger router: forwards native CP calldata to a pool via `Call`.
+ * **v1:** **128-byte** inner. **v2:** **160-byte** inner (v5 `swap_to`). **v3:** **192-byte** inner (v5 `remove_liquidity_to`).
+ * Matches `boing_execution::native_dex_ledger_router`. See `docs/NATIVE-DEX-LEDGER-ROUTER.md`.
+ */
+import type { SimulateResult } from './types.js';
+/** v1 `forward_pool_call` selector (low byte of word0). */
+export declare const SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD = 224;
+/** v2 forward selector — **224-byte** outer calldata, **160-byte** inner. */
+export declare const SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD_V2 = 225;
+/** v3 forward selector — **256-byte** outer calldata, **192-byte** inner. */
+export declare const SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD_V3 = 226;
+/**
+ * Build **192** bytes: router selector + pool + inner pool calldata (**128** bytes).
+ * `innerPoolCalldata128` must be exactly **128** bytes (same layout as native CP pool swap / add / remove).
+ */
+export declare function encodeNativeDexLedgerRouterForwardCalldata(poolHex32: string, innerPoolCalldata128: Uint8Array): Uint8Array;
+export declare function encodeNativeDexLedgerRouterForwardCalldataHex(poolHex32: string, innerPoolCalldata128: Uint8Array): string;
+/**
+ * Build **224** bytes: router selector **`0xE1`** + pool + inner pool calldata (**160** bytes, e.g. v5 `swap_to` from `encodeNativeAmmSwapToCalldata`).
+ */
+export declare function encodeNativeDexLedgerRouterForwardCalldataV2(poolHex32: string, innerPoolCalldata160: Uint8Array): Uint8Array;
+export declare function encodeNativeDexLedgerRouterForwardCalldataV2Hex(poolHex32: string, innerPoolCalldata160: Uint8Array): string;
+/**
+ * Build **256** bytes: router selector **`0xE2`** + pool + inner pool calldata (**192** bytes, e.g. `encodeNativeAmmRemoveLiquidityToCalldata`).
+ */
+export declare function encodeNativeDexLedgerRouterForwardCalldataV3(poolHex32: string, innerPoolCalldata192: Uint8Array): Uint8Array;
+export declare function encodeNativeDexLedgerRouterForwardCalldataV3Hex(poolHex32: string, innerPoolCalldata192: Uint8Array): string;
+/**
+ * Access list: signer, router, and **pool** (router `Call`s pool state).
+ */
+export declare function buildNativeDexLedgerRouterAccessList(senderHex32: string, routerHex32: string, poolHex32: string): {
+    read: string[];
+    write: string[];
+};
+export declare function buildNativeDexLedgerRouterContractCallTx(senderHex32: string, routerHex32: string, poolHex32: string, innerPoolCalldata128: Uint8Array): {
+    type: 'contract_call';
+    contract: string;
+    calldata: string;
+    access_list: {
+        read: string[];
+        write: string[];
+    };
+};
+export declare function mergeNativeDexLedgerRouterAccessListWithSimulation(senderHex32: string, routerHex32: string, poolHex32: string, sim: SimulateResult): {
+    read: string[];
+    write: string[];
+};
+export declare function buildNativeDexLedgerRouterV2ContractCallTx(senderHex32: string, routerHex32: string, poolHex32: string, innerPoolCalldata160: Uint8Array): {
+    type: 'contract_call';
+    contract: string;
+    calldata: string;
+    access_list: {
+        read: string[];
+        write: string[];
+    };
+};
+export declare function buildNativeDexLedgerRouterV3ContractCallTx(senderHex32: string, routerHex32: string, poolHex32: string, innerPoolCalldata192: Uint8Array): {
+    type: 'contract_call';
+    contract: string;
+    calldata: string;
+    access_list: {
+        read: string[];
+        write: string[];
+    };
+};
+//# sourceMappingURL=nativeDexLedgerRouter.d.ts.map

package/dist/nativeDexLedgerRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeDexLedgerRouter.d.ts","sourceRoot":"","sources":["../src/nativeDexLedgerRouter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,2DAA2D;AAC3D,eAAO,MAAM,yCAAyC,MAAO,CAAC;AAC9D,6EAA6E;AAC7E,eAAO,MAAM,4CAA4C,MAAO,CAAC;AACjE,6EAA6E;AAC7E,eAAO,MAAM,4CAA4C,MAAO,CAAC;AAQjE;;;GAGG;AACH,wBAAgB,0CAA0C,CACxD,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B,UAAU,CAUZ;AAED,wBAAgB,6CAA6C,CAC3D,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,4CAA4C,CAC1D,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B,UAAU,CAUZ;AAED,wBAAgB,+CAA+C,CAC7D,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,4CAA4C,CAC1D,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B,UAAU,CAUZ;AAED,wBAAgB,+CAA+C,CAC7D,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,oCAAoC,CAClD,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAMrC;AAED,wBAAgB,wCAAwC,CACtD,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B;IACD,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClD,CAOA;AAED,wBAAgB,kDAAkD,CAChE,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,cAAc,GAClB;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAGrC;AAED,wBAAgB,0CAA0C,CACxD,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B;IACD,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClD,CAOA;AAED,wBAAgB,0CAA0C,CACxD,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,oBAAoB,EAAE,UAAU,GAC/B;IACD,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClD,CAOA"}

package/dist/nativeDexLedgerRouter.js

@@ -0,0 +1,108 @@
+/**
+ * Ledger router: forwards native CP calldata to a pool via `Call`.
+ * **v1:** **128-byte** inner. **v2:** **160-byte** inner (v5 `swap_to`). **v3:** **192-byte** inner (v5 `remove_liquidity_to`).
+ * Matches `boing_execution::native_dex_ledger_router`. See `docs/NATIVE-DEX-LEDGER-ROUTER.md`.
+ */
+import { bytesToHex, hexToBytes, validateHex32 } from './hex.js';
+import { mergeAccessListWithSimulation } from './accessList.js';
+/** v1 `forward_pool_call` selector (low byte of word0). */
+export const SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD = 0xe0;
+/** v2 forward selector — **224-byte** outer calldata, **160-byte** inner. */
+export const SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD_V2 = 0xe1;
+/** v3 forward selector — **256-byte** outer calldata, **192-byte** inner. */
+export const SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD_V3 = 0xe2;
+function selectorWord(selector) {
+    const w = new Uint8Array(32);
+    w[31] = selector & 0xff;
+    return w;
+}
+/**
+ * Build **192** bytes: router selector + pool + inner pool calldata (**128** bytes).
+ * `innerPoolCalldata128` must be exactly **128** bytes (same layout as native CP pool swap / add / remove).
+ */
+export function encodeNativeDexLedgerRouterForwardCalldata(poolHex32, innerPoolCalldata128) {
+    if (innerPoolCalldata128.length !== 128) {
+        throw new Error(`inner pool calldata must be 128 bytes, got ${innerPoolCalldata128.length}`);
+    }
+    const pool = hexToBytes(validateHex32(poolHex32));
+    const out = new Uint8Array(192);
+    out.set(selectorWord(SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD));
+    out.set(pool, 32);
+    out.set(innerPoolCalldata128, 64);
+    return out;
+}
+export function encodeNativeDexLedgerRouterForwardCalldataHex(poolHex32, innerPoolCalldata128) {
+    return bytesToHex(encodeNativeDexLedgerRouterForwardCalldata(poolHex32, innerPoolCalldata128));
+}
+/**
+ * Build **224** bytes: router selector **`0xE1`** + pool + inner pool calldata (**160** bytes, e.g. v5 `swap_to` from `encodeNativeAmmSwapToCalldata`).
+ */
+export function encodeNativeDexLedgerRouterForwardCalldataV2(poolHex32, innerPoolCalldata160) {
+    if (innerPoolCalldata160.length !== 160) {
+        throw new Error(`inner pool calldata must be 160 bytes, got ${innerPoolCalldata160.length}`);
+    }
+    const pool = hexToBytes(validateHex32(poolHex32));
+    const out = new Uint8Array(224);
+    out.set(selectorWord(SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD_V2));
+    out.set(pool, 32);
+    out.set(innerPoolCalldata160, 64);
+    return out;
+}
+export function encodeNativeDexLedgerRouterForwardCalldataV2Hex(poolHex32, innerPoolCalldata160) {
+    return bytesToHex(encodeNativeDexLedgerRouterForwardCalldataV2(poolHex32, innerPoolCalldata160));
+}
+/**
+ * Build **256** bytes: router selector **`0xE2`** + pool + inner pool calldata (**192** bytes, e.g. `encodeNativeAmmRemoveLiquidityToCalldata`).
+ */
+export function encodeNativeDexLedgerRouterForwardCalldataV3(poolHex32, innerPoolCalldata192) {
+    if (innerPoolCalldata192.length !== 192) {
+        throw new Error(`inner pool calldata must be 192 bytes, got ${innerPoolCalldata192.length}`);
+    }
+    const pool = hexToBytes(validateHex32(poolHex32));
+    const out = new Uint8Array(256);
+    out.set(selectorWord(SELECTOR_NATIVE_DEX_LEDGER_ROUTER_FORWARD_V3));
+    out.set(pool, 32);
+    out.set(innerPoolCalldata192, 64);
+    return out;
+}
+export function encodeNativeDexLedgerRouterForwardCalldataV3Hex(poolHex32, innerPoolCalldata192) {
+    return bytesToHex(encodeNativeDexLedgerRouterForwardCalldataV3(poolHex32, innerPoolCalldata192));
+}
+/**
+ * Access list: signer, router, and **pool** (router `Call`s pool state).
+ */
+export function buildNativeDexLedgerRouterAccessList(senderHex32, routerHex32, poolHex32) {
+    const s = validateHex32(senderHex32).toLowerCase();
+    const r = validateHex32(routerHex32).toLowerCase();
+    const p = validateHex32(poolHex32).toLowerCase();
+    const xs = [s, r, p].sort();
+    return { read: xs, write: xs };
+}
+export function buildNativeDexLedgerRouterContractCallTx(senderHex32, routerHex32, poolHex32, innerPoolCalldata128) {
+    return {
+        type: 'contract_call',
+        contract: validateHex32(routerHex32).toLowerCase(),
+        calldata: encodeNativeDexLedgerRouterForwardCalldataHex(poolHex32, innerPoolCalldata128),
+        access_list: buildNativeDexLedgerRouterAccessList(senderHex32, routerHex32, poolHex32),
+    };
+}
+export function mergeNativeDexLedgerRouterAccessListWithSimulation(senderHex32, routerHex32, poolHex32, sim) {
+    const base = buildNativeDexLedgerRouterAccessList(senderHex32, routerHex32, poolHex32);
+    return mergeAccessListWithSimulation(base.read, base.write, sim);
+}
+export function buildNativeDexLedgerRouterV2ContractCallTx(senderHex32, routerHex32, poolHex32, innerPoolCalldata160) {
+    return {
+        type: 'contract_call',
+        contract: validateHex32(routerHex32).toLowerCase(),
+        calldata: encodeNativeDexLedgerRouterForwardCalldataV2Hex(poolHex32, innerPoolCalldata160),
+        access_list: buildNativeDexLedgerRouterAccessList(senderHex32, routerHex32, poolHex32),
+    };
+}
+export function buildNativeDexLedgerRouterV3ContractCallTx(senderHex32, routerHex32, poolHex32, innerPoolCalldata192) {
+    return {
+        type: 'contract_call',
+        contract: validateHex32(routerHex32).toLowerCase(),
+        calldata: encodeNativeDexLedgerRouterForwardCalldataV3Hex(poolHex32, innerPoolCalldata192),
+        access_list: buildNativeDexLedgerRouterAccessList(senderHex32, routerHex32, poolHex32),
+    };
+}

package/dist/nativeDexLpPositions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Resolve native LP **vault → pool / share token** from on-chain storage (model **A** path) and
+ * read **LP share balances** for an owner. Replaces static env maps when the vault is configured.
+ *
+ * See [NATIVE-AMM-LP-VAULT.md](../docs/NATIVE-AMM-LP-VAULT.md), [PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md](../docs/PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md) §2.
+ */
+import type { BoingClient } from './client.js';
+export type NativeAmmVaultPoolResolution = {
+    vaultHex: `0x${string}`;
+    configured: boolean;
+    poolHex: `0x${string}` | null;
+    shareTokenHex: `0x${string}` | null;
+};
+/**
+ * Read **`configure(pool, share)`** storage for one vault (`boing_getContractStorage`).
+ */
+export declare function resolveNativeAmmVaultPoolMapping(client: BoingClient, vaultHex32: string): Promise<NativeAmmVaultPoolResolution>;
+/**
+ * Parallel **`resolveNativeAmmVaultPoolMapping`** (bounded concurrency).
+ */
+export declare function resolveNativeAmmVaultPoolMappings(client: BoingClient, vaultHexes: readonly string[], concurrency?: number): Promise<NativeAmmVaultPoolResolution[]>;
+export type NativeDexLpVaultSharePositionForOwner = {
+    vaultHex: `0x${string}`;
+    ownerHex: `0x${string}`;
+    poolHex: `0x${string}` | null;
+    shareTokenHex: `0x${string}` | null;
+    /** LP share units (u128) when vault configured and share token known; otherwise `null`. */
+    shareBalanceRaw: bigint | null;
+    note: string;
+};
+/**
+ * **Model A (vault + share token):** resolve vault storage, then read holder balance on the share token.
+ * Does not prove minter is the vault — use **`fetchNativeAmmLpVaultProductReadiness`** for product gating.
+ */
+export declare function fetchNativeDexLpVaultSharePositionForOwner(client: BoingClient, input: {
+    vaultHex32: string;
+    ownerHex32: string;
+}): Promise<NativeDexLpVaultSharePositionForOwner>;
+//# sourceMappingURL=nativeDexLpPositions.d.ts.map

package/dist/nativeDexLpPositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeDexLpPositions.d.ts","sourceRoot":"","sources":["../src/nativeDexLpPositions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,KAAK,MAAM,EAAE,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,KAAK,MAAM,EAAE,GAAG,IAAI,CAAC;CACrC,CAAC;AAEF;;GAEG;AACH,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,4BAA4B,CAAC,CASvC;AAED;;GAEG;AACH,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,WAAW,GAAE,MAAU,GACtB,OAAO,CAAC,4BAA4B,EAAE,CAAC,CAIzC;AAED,MAAM,MAAM,qCAAqC,GAAG;IAClD,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;IACxB,OAAO,EAAE,KAAK,MAAM,EAAE,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,KAAK,MAAM,EAAE,GAAG,IAAI,CAAC;IACpC,2FAA2F;IAC3F,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;GAGG;AACH,wBAAsB,0CAA0C,CAC9D,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAChD,OAAO,CAAC,qCAAqC,CAAC,CAkChD"}

package/dist/nativeDexLpPositions.js

@@ -0,0 +1,69 @@
+/**
+ * Resolve native LP **vault → pool / share token** from on-chain storage (model **A** path) and
+ * read **LP share balances** for an owner. Replaces static env maps when the vault is configured.
+ *
+ * See [NATIVE-AMM-LP-VAULT.md](../docs/NATIVE-AMM-LP-VAULT.md), [PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md](../docs/PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md) §2.
+ */
+import { validateHex32 } from './hex.js';
+import { mapWithConcurrencyLimit } from './indexerBatch.js';
+import { fetchNativeAmmLpVaultStorageSnapshot } from './nativeAmmLpVault.js';
+import { fetchLpShareTokenBalanceRaw } from './nativeLpShareToken.js';
+/**
+ * Read **`configure(pool, share)`** storage for one vault (`boing_getContractStorage`).
+ */
+export async function resolveNativeAmmVaultPoolMapping(client, vaultHex32) {
+    const vaultHex = validateHex32(vaultHex32).toLowerCase();
+    const snap = await fetchNativeAmmLpVaultStorageSnapshot(client, vaultHex);
+    return {
+        vaultHex,
+        configured: snap.configured,
+        poolHex: snap.poolHex,
+        shareTokenHex: snap.shareTokenHex,
+    };
+}
+/**
+ * Parallel **`resolveNativeAmmVaultPoolMapping`** (bounded concurrency).
+ */
+export async function resolveNativeAmmVaultPoolMappings(client, vaultHexes, concurrency = 4) {
+    return mapWithConcurrencyLimit([...vaultHexes], concurrency, (v) => resolveNativeAmmVaultPoolMapping(client, v));
+}
+/**
+ * **Model A (vault + share token):** resolve vault storage, then read holder balance on the share token.
+ * Does not prove minter is the vault — use **`fetchNativeAmmLpVaultProductReadiness`** for product gating.
+ */
+export async function fetchNativeDexLpVaultSharePositionForOwner(client, input) {
+    const vaultHex = validateHex32(input.vaultHex32).toLowerCase();
+    const ownerHex = validateHex32(input.ownerHex32).toLowerCase();
+    const snap = await fetchNativeAmmLpVaultStorageSnapshot(client, vaultHex);
+    if (!snap.configured || snap.shareTokenHex == null) {
+        return {
+            vaultHex,
+            ownerHex,
+            poolHex: snap.poolHex,
+            shareTokenHex: snap.shareTokenHex,
+            shareBalanceRaw: null,
+            note: snap.configured ? 'vault_missing_share_token' : 'vault_not_configured',
+        };
+    }
+    try {
+        const shareBalanceRaw = await fetchLpShareTokenBalanceRaw(client, snap.shareTokenHex, ownerHex);
+        return {
+            vaultHex,
+            ownerHex,
+            poolHex: snap.poolHex,
+            shareTokenHex: snap.shareTokenHex,
+            shareBalanceRaw,
+            note: 'ok',
+        };
+    }
+    catch (e) {
+        return {
+            vaultHex,
+            ownerHex,
+            poolHex: snap.poolHex,
+            shareTokenHex: snap.shareTokenHex,
+            shareBalanceRaw: null,
+            note: e instanceof Error ? e.message : String(e),
+        };
+    }
+}

package/dist/nativeDexNftIndexer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Collect latest **ERC-721 `Transfer`** ownership rows for one contract over a block range.
+ * Used by **`native-dex-indexer`** D1 table **`directory_nft_owner`** (snapshot per sync).
+ */
+import type { BoingClient } from './client.js';
+export type NativeDexIndexedNftOwnerRow = {
+    contractHex: string;
+    /** Decimal string (arbitrary size uint256). */
+    tokenIdDec: string;
+    ownerHex: string;
+    lastBlockHeight: number;
+    txId: string;
+    logIndex: number;
+};
+export type CollectNftOwnersFromErc721TransfersOptions = {
+    fromBlock: number;
+    toBlock: number;
+    maxConcurrent?: number;
+};
+/**
+ * **`boing_getLogs`** on **`contractHex`** for **`Transfer`**, then fold to **last** owner per **`tokenId`**
+ * within the merged log order `(block_height, tx_index, log_index)`.
+ */
+export declare function collectNftOwnersFromErc721Transfers(client: BoingClient, contractHex32: string, opts: CollectNftOwnersFromErc721TransfersOptions): Promise<NativeDexIndexedNftOwnerRow[]>;
+export { ERC721_TRANSFER_TOPIC0_HEX } from './erc721Logs.js';
+//# sourceMappingURL=nativeDexNftIndexer.d.ts.map

package/dist/nativeDexNftIndexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeDexNftIndexer.d.ts","sourceRoot":"","sources":["../src/nativeDexNftIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,0CAA0C,GAAG;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;GAGG;AACH,wBAAsB,mCAAmC,CACvD,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,0CAA0C,GAC/C,OAAO,CAAC,2BAA2B,EAAE,CAAC,CAyCxC;AAED,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/nativeDexNftIndexer.js

@@ -0,0 +1,50 @@
+/**
+ * Collect latest **ERC-721 `Transfer`** ownership rows for one contract over a block range.
+ * Used by **`native-dex-indexer`** D1 table **`directory_nft_owner`** (snapshot per sync).
+ */
+import { ERC721_TRANSFER_TOPIC0_HEX, filterMapErc721TransferRpcLogs } from './erc721Logs.js';
+import { validateHex32 } from './hex.js';
+import { getLogsChunked } from './indexerBatch.js';
+/**
+ * **`boing_getLogs`** on **`contractHex`** for **`Transfer`**, then fold to **last** owner per **`tokenId`**
+ * within the merged log order `(block_height, tx_index, log_index)`.
+ */
+export async function collectNftOwnersFromErc721Transfers(client, contractHex32, opts) {
+    const contract = validateHex32(String(contractHex32).trim()).toLowerCase();
+    const fromB = Math.max(0, Math.floor(opts.fromBlock));
+    const toB = Math.max(fromB, Math.floor(opts.toBlock));
+    const logs = await getLogsChunked(client, {
+        fromBlock: fromB,
+        toBlock: toB,
+        address: contract,
+        topics: [ERC721_TRANSFER_TOPIC0_HEX],
+    }, { maxConcurrent: opts.maxConcurrent ?? 1 });
+    const parsed = filterMapErc721TransferRpcLogs(logs);
+    const latest = new Map();
+    for (const t of parsed) {
+        const tokenIdDec = t.tokenId.toString(10);
+        const prev = latest.get(tokenIdDec);
+        if (prev == null ||
+            t.blockHeight > prev.lastBlockHeight ||
+            (t.blockHeight === prev.lastBlockHeight && t.txId.localeCompare(prev.txId) > 0) ||
+            (t.blockHeight === prev.lastBlockHeight && t.txId === prev.txId && t.logIndex > prev.logIndex)) {
+            latest.set(tokenIdDec, {
+                contractHex: contract,
+                tokenIdDec,
+                ownerHex: t.toHex,
+                lastBlockHeight: t.blockHeight,
+                txId: t.txId,
+                logIndex: t.logIndex,
+            });
+        }
+    }
+    return [...latest.values()].sort((a, b) => {
+        if (a.lastBlockHeight !== b.lastBlockHeight)
+            return a.lastBlockHeight - b.lastBlockHeight;
+        const c = a.txId.localeCompare(b.txId);
+        if (c !== 0)
+            return c;
+        return a.logIndex - b.logIndex;
+    });
+}
+export { ERC721_TRANSFER_TOPIC0_HEX } from './erc721Logs.js';

package/dist/nativeDexPoolHistory.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Collect native AMM **`Log2`** events for pools over a block range (materialized snapshot input).
+ * Used by the **`native-dex-indexer`** Worker D1 table **`directory_pool_events`** — **not** reorg-safe;
+ * see [PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md](../docs/PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md) §3.
+ */
+import type { BoingClient } from './client.js';
+import { type NativeAmmLog2Kind, type NativeAmmRpcLogParsed } from './nativeAmmLogs.js';
+export type NativeDexMaterializedPoolEvent = {
+    kind: NativeAmmLog2Kind;
+    poolHex: string;
+    blockHeight: number;
+    /** Block hash from **`boing_getBlockByHeight`** at ingest time (`null` if node omitted `hash`). */
+    blockHash: string | null;
+    txId: string;
+    logIndex: number;
+    callerHex: string;
+    /** Stringified integers for JSON columns. */
+    payload: Record<string, string>;
+};
+export declare function materializeNativeAmmPoolEvent(ev: NativeAmmRpcLogParsed, poolHexLower: string): NativeDexMaterializedPoolEvent;
+export type CollectNativeDexPoolEventsOptions = {
+    /** Inclusive; clamped to `>= 0`. */
+    fromBlock: number;
+    /** Inclusive. */
+    toBlock: number;
+    maxConcurrent?: number;
+    /**
+     * When **`true`** (default), batch **`boing_getBlockByHeight`** to fill **`blockHash`** on each event.
+     */
+    attachBlockHashes?: boolean;
+};
+/**
+ * Set **`blockHash`** on each event from **`boing_getBlockByHeight(blockHeight)`** (deduped per height).
+ */
+export declare function hydrateNativeDexPoolEventsWithBlockHashes(client: BoingClient, events: NativeDexMaterializedPoolEvent[]): Promise<void>;
+/**
+ * For each pool, **`boing_getLogs`** over **`[fromBlock, toBlock]`** and return parsed native AMM **`Log2`** rows.
+ */
+export declare function collectNativeDexPoolEventsForPools(client: BoingClient, poolHexes: readonly string[], opts: CollectNativeDexPoolEventsOptions): Promise<NativeDexMaterializedPoolEvent[]>;
+//# sourceMappingURL=nativeDexPoolHistory.d.ts.map

package/dist/nativeDexPoolHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeDexPoolHistory.d.ts","sourceRoot":"","sources":["../src/nativeDexPoolHistory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC3B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,8BAA8B,GAAG;IAC3C,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,mGAAmG;IACnG,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AA2BF,wBAAgB,6BAA6B,CAC3C,EAAE,EAAE,qBAAqB,EACzB,YAAY,EAAE,MAAM,GACnB,8BAA8B,CAWhC;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,wBAAsB,yCAAyC,CAC7D,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,8BAA8B,EAAE,GACvC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED;;GAEG;AACH,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,IAAI,EAAE,iCAAiC,GACtC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAyC3C"}

package/dist/nativeDexPoolHistory.js

@@ -0,0 +1,110 @@
+/**
+ * Collect native AMM **`Log2`** events for pools over a block range (materialized snapshot input).
+ * Used by the **`native-dex-indexer`** Worker D1 table **`directory_pool_events`** — **not** reorg-safe;
+ * see [PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md](../docs/PROTOCOL_NATIVE_DEX_RPC_AND_INDEXING_ROADMAP.md) §3.
+ */
+import { validateHex32 } from './hex.js';
+import { getLogsChunked } from './indexerBatch.js';
+import { filterMapNativeAmmRpcLogs, } from './nativeAmmLogs.js';
+function payloadFromParsed(ev) {
+    switch (ev.kind) {
+        case 'swap':
+            return {
+                direction: ev.direction.toString(),
+                amountIn: ev.amountIn.toString(),
+                amountOutAfterFee: ev.amountOutAfterFee.toString(),
+            };
+        case 'addLiquidity':
+            return {
+                amountA: ev.amountA.toString(),
+                amountB: ev.amountB.toString(),
+                lpMinted: ev.lpMinted.toString(),
+            };
+        case 'removeLiquidity':
+            return {
+                liquidityBurned: ev.liquidityBurned.toString(),
+                amountAOut: ev.amountAOut.toString(),
+                amountBOut: ev.amountBOut.toString(),
+            };
+        default:
+            return {};
+    }
+}
+export function materializeNativeAmmPoolEvent(ev, poolHexLower) {
+    return {
+        kind: ev.kind,
+        poolHex: poolHexLower,
+        blockHeight: ev.block_height,
+        blockHash: null,
+        txId: ev.tx_id,
+        logIndex: ev.log_index,
+        callerHex: ev.callerHex,
+        payload: payloadFromParsed(ev),
+    };
+}
+/**
+ * Set **`blockHash`** on each event from **`boing_getBlockByHeight(blockHeight)`** (deduped per height).
+ */
+export async function hydrateNativeDexPoolEventsWithBlockHashes(client, events) {
+    if (events.length === 0)
+        return;
+    const heights = [...new Set(events.map((e) => e.blockHeight))].sort((a, b) => a - b);
+    const hashByHeight = new Map();
+    for (const h of heights) {
+        try {
+            const blk = await client.getBlockByHeight(h, false);
+            const raw = blk?.hash;
+            const norm = typeof raw === 'string' && /^0x[0-9a-f]{64}$/i.test(raw) ? raw.toLowerCase() : null;
+            hashByHeight.set(h, norm);
+        }
+        catch {
+            hashByHeight.set(h, null);
+        }
+    }
+    for (const ev of events) {
+        ev.blockHash = hashByHeight.get(ev.blockHeight) ?? null;
+    }
+}
+/**
+ * For each pool, **`boing_getLogs`** over **`[fromBlock, toBlock]`** and return parsed native AMM **`Log2`** rows.
+ */
+export async function collectNativeDexPoolEventsForPools(client, poolHexes, opts) {
+    const fromB = Math.max(0, Math.floor(opts.fromBlock));
+    const toB = Math.max(fromB, Math.floor(opts.toBlock));
+    const out = [];
+    const maxConcurrent = opts.maxConcurrent ?? 1;
+    for (const raw of poolHexes) {
+        let pool;
+        try {
+            pool = validateHex32(String(raw).trim()).toLowerCase();
+        }
+        catch {
+            continue;
+        }
+        try {
+            const logs = await getLogsChunked(client, { fromBlock: fromB, toBlock: toB, address: pool }, { maxConcurrent });
+            const parsed = filterMapNativeAmmRpcLogs(logs);
+            for (const ev of parsed) {
+                if (ev.address && ev.address.toLowerCase() !== pool)
+                    continue;
+                out.push(materializeNativeAmmPoolEvent(ev, pool));
+            }
+        }
+        catch {
+            /* skip pool on RPC errors */
+        }
+    }
+    out.sort((a, b) => {
+        if (a.blockHeight !== b.blockHeight)
+            return a.blockHeight - b.blockHeight;
+        const c = a.txId.localeCompare(b.txId);
+        if (c !== 0)
+            return c;
+        return a.logIndex - b.logIndex;
+    });
+    const attach = opts.attachBlockHashes !== false;
+    if (attach && out.length > 0) {
+        await hydrateNativeDexPoolEventsWithBlockHashes(client, out);
+    }
+    return out;
+}

package/dist/nativeDexReceiptArchive.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bounded **execution log** rows from **`boing_getBlockByHeight(..., true)`** (receipts included).
+ * For optional **`directory_receipt_log`** in the native-dex-indexer Worker — not full-chain history.
+ */
+import type { BoingClient } from './client.js';
+export type NativeDexArchivedReceiptLogRow = {
+    blockHeight: number;
+    blockHash: string | null;
+    txId: string;
+    /** Index within **`receipt.logs`** for this transaction. */
+    logIndex: number;
+    topic0Hex: string | null;
+    topicsJson: string;
+    dataHex: string;
+};
+export type CollectArchivedReceiptLogRowsOptions = {
+    maxConcurrent?: number;
+    /** Safety cap per sync (default **3000**). */
+    maxRows?: number;
+};
+/**
+ * Walk **`[fromHeight, toHeight]`** inclusive; missing blocks are **omitted** (`onMissingBlock: 'omit'`).
+ */
+export declare function collectArchivedReceiptLogRows(client: BoingClient, fromHeight: number, toHeight: number, options?: CollectArchivedReceiptLogRowsOptions): Promise<NativeDexArchivedReceiptLogRow[]>;
+//# sourceMappingURL=nativeDexReceiptArchive.d.ts.map

package/dist/nativeDexReceiptArchive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nativeDexReceiptArchive.d.ts","sourceRoot":"","sources":["../src/nativeDexReceiptArchive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,MAAM,MAAM,8BAA8B,GAAG;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,oCAAoC,GAC7C,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAoC3C"}

package/dist/nativeDexReceiptArchive.js

@@ -0,0 +1,47 @@
+/**
+ * Bounded **execution log** rows from **`boing_getBlockByHeight(..., true)`** (receipts included).
+ * For optional **`directory_receipt_log`** in the native-dex-indexer Worker — not full-chain history.
+ */
+import { fetchBlocksWithReceiptsForHeightRange } from './indexerBatch.js';
+import { iterBlockReceiptLogs, logTopic0 } from './receiptLogs.js';
+/**
+ * Walk **`[fromHeight, toHeight]`** inclusive; missing blocks are **omitted** (`onMissingBlock: 'omit'`).
+ */
+export async function collectArchivedReceiptLogRows(client, fromHeight, toHeight, options) {
+    const fromB = Math.max(0, Math.floor(fromHeight));
+    const toB = Math.max(fromB, Math.floor(toHeight));
+    const maxRows = options?.maxRows ?? 3000;
+    const bundles = await fetchBlocksWithReceiptsForHeightRange(client, fromB, toB, {
+        onMissingBlock: 'omit',
+        maxConcurrent: options?.maxConcurrent ?? 1,
+    });
+    const out = [];
+    for (const { height, block } of bundles) {
+        const bh = block.hash;
+        const blockHash = typeof bh === 'string' && /^0x[0-9a-f]{64}$/i.test(bh) ? bh.toLowerCase() : null;
+        for (const { receipt, log, logIndex } of iterBlockReceiptLogs(block)) {
+            if (out.length >= maxRows)
+                return out;
+            let topic0Hex = null;
+            try {
+                topic0Hex = logTopic0(log) ?? null;
+            }
+            catch {
+                topic0Hex = null;
+            }
+            const topics = log.topics ?? [];
+            const topicsJson = JSON.stringify(topics.map((t) => String(t).toLowerCase()));
+            const dataHex = String(log.data || '0x').toLowerCase();
+            out.push({
+                blockHeight: height,
+                blockHash,
+                txId: receipt.tx_id,
+                logIndex,
+                topic0Hex,
+                topicsJson,
+                dataHex,
+            });
+        }
+    }
+    return out;
+}