sol-parser-sdk 0.5.15 → 0.5.16

package/dist/shredstream/entries_decode.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bincodeVecEntryCount = bincodeVecEntryCount;
 exports.decodeCompactU16 = decodeCompactU16;
@@ -6,6 +9,8 @@ exports.parseTransaction = parseTransaction;
 exports.decodeEntriesBincodeFlat = decodeEntriesBincodeFlat;
 exports.decodeEntriesBincodeNested = decodeEntriesBincodeNested;
 exports.decodeShredstreamEntriesBincode = decodeShredstreamEntriesBincode;
+const bs58_1 = __importDefault(require("bs58"));
+const wire_transaction_js_1 = require("../wire_transaction.js");
 const wire_to_shred_tx_js_1 = require("./wire_to_shred_tx.js");
 const MAX_VEC_ENTRIES = 100_000;
 function readU64LE(buf, offset) {
@@ -43,94 +48,13 @@ function decodeCompactU16(buf, pos) {
 }
 /** 返回 (txWireLength, signatures)；失败返回 null */
 function parseTransaction(buf, pos) {
-    const start = pos;
-    if (pos >= buf.length)
-        return null;
-    const sigCountEnc = decodeCompactU16(buf, pos);
-    if (!sigCountEnc)
-        return null;
-    let p = pos + sigCountEnc.bytes;
-    const sigCount = sigCountEnc.value;
-    const sigsEnd = p + sigCount * 64;
-    if (sigsEnd > buf.length)
-        return null;
-    const sigs = [];
-    for (let i = 0; i < sigCount; i++) {
-        sigs.push(buf.subarray(p, p + 64));
-        p += 64;
+    try {
+        const { transaction, length } = (0, wire_transaction_js_1.decodeWireTransaction)(buf, pos, false);
+        return { txLen: length, sigs: transaction.signatures.map(s => bs58_1.default.decode(s)) };
     }
-    if (p >= buf.length)
-        return null;
-    const msgFirst = buf[p];
-    const isV0 = msgFirst >= 0x80;
-    if (isV0)
-        p += 1;
-    p += 3;
-    if (p > buf.length)
-        return null;
-    const acctEnc = decodeCompactU16(buf, p);
-    if (!acctEnc)
-        return null;
-    p += acctEnc.bytes;
-    p += acctEnc.value * 32;
-    if (p > buf.length)
-        return null;
-    p += 32;
-    if (p > buf.length)
-        return null;
-    const ixCountEnc = decodeCompactU16(buf, p);
-    if (!ixCountEnc)
+    catch {
         return null;
-    p += ixCountEnc.bytes;
-    const ixCount = ixCountEnc.value;
-    for (let ix = 0; ix < ixCount; ix++) {
-        p += 1;
-        if (p > buf.length)
-            return null;
-        const acctLenEnc = decodeCompactU16(buf, p);
-        if (!acctLenEnc)
-            return null;
-        p += acctLenEnc.bytes;
-        p += acctLenEnc.value;
-        if (p > buf.length)
-            return null;
-        const dataLenEnc = decodeCompactU16(buf, p);
-        if (!dataLenEnc)
-            return null;
-        p += dataLenEnc.bytes;
-        p += dataLenEnc.value;
-        if (p > buf.length)
-            return null;
-    }
-    if (isV0) {
-        if (p >= buf.length)
-            return null;
-        const atlCountEnc = decodeCompactU16(buf, p);
-        if (!atlCountEnc)
-            return null;
-        p += atlCountEnc.bytes;
-        const atlCount = atlCountEnc.value;
-        for (let atl = 0; atl < atlCount; atl++) {
-            p += 32;
-            if (p > buf.length)
-                return null;
-            const wLenEnc = decodeCompactU16(buf, p);
-            if (!wLenEnc)
-                return null;
-            p += wLenEnc.bytes;
-            p += wLenEnc.value;
-            if (p > buf.length)
-                return null;
-            const rLenEnc = decodeCompactU16(buf, p);
-            if (!rLenEnc)
-                return null;
-            p += rLenEnc.bytes;
-            p += rLenEnc.value;
-            if (p > buf.length)
-                return null;
-        }
     }
-    return { txLen: p - start, sigs };
 }
 class BatchDecoder {
     buffer = new Uint8Array(0);

package/dist/shredstream/instruction_parse.d.ts

@@ -21,7 +21,7 @@ export type ShredWasmTx = {
     accounts: string[];
     instructions?: ShredWasmCompiledIx[];
     /** 缺省则按仅静态账户处理 */
-    messageVersion?: "legacy" | "v0";
+    messageVersion?: "legacy" | "v0" | "v1";
     header?: MessageHeader;
     recentBlockhash?: Uint8Array;
     addressTableLookups?: ShredAddressTableLookup[];
@@ -29,6 +29,6 @@ export type ShredWasmTx = {
 /**
  * 使用已解析的完整账户表（静态+ALT）解析外层指令。
  */
-export declare function dexEventsFromShredWasmTxWithFullKeys(tx: ShredWasmTx, fullAccountKeys: string[], slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];
+export declare function dexEventsFromShredWasmTxWithFullKeys(tx: ShredWasmTx, fullAccountKeys: string[], slot: number | bigint | string, txIndex: number | bigint | string, grpcRecvUs: number | bigint | string, eventTypeFilter?: EventTypeFilter): DexEvent[];
 /** 仅静态账户表（无 RPC 时；V0+ALT 缺失账户以默认 pubkey 占位） */
-export declare function dexEventsFromShredWasmTx(tx: ShredWasmTx, slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];
+export declare function dexEventsFromShredWasmTx(tx: ShredWasmTx, slot: number | bigint | string, txIndex: number | bigint | string, grpcRecvUs: number | bigint | string, eventTypeFilter?: EventTypeFilter): DexEvent[];

package/dist/shredstream/proto_types.d.ts

@@ -4,6 +4,6 @@
  */
 export type SubscribeEntriesRequest = Record<string, never>;
 export interface ShredstreamEntryMessage {
-    slot: number | string | bigint;
+    slot: number | bigint | string | string | bigint;
     entries: Uint8Array | Buffer;
 }

package/dist/shredstream/wire_to_shred_tx.d.ts

@@ -1,2 +1,2 @@
-import type { ShredWasmTx } from "./instruction_parse.js";
+import type { ShredWasmTx } from './instruction_parse.js';
 export declare function wireBytesToShredWasmTx(raw: Uint8Array): ShredWasmTx | null;

package/dist/shredstream/wire_to_shred_tx.js

@@ -4,54 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wireBytesToShredWasmTx = wireBytesToShredWasmTx;
-/**
- * 线格式交易字节 → `ShredWasmTx`（与原 wasm-pack 展开字段对齐，供 `parseInstructionUnified`）。
- */
-const web3_js_1 = require("@solana/web3.js");
+/** Native wire decoding shared with RPC routes, including V1 without ALT. */
 const bs58_1 = __importDefault(require("bs58"));
+const wire_transaction_js_1 = require("../wire_transaction.js");
 function wireBytesToShredWasmTx(raw) {
     try {
-        const vt = web3_js_1.VersionedTransaction.deserialize(Buffer.from(raw));
-        const sig0 = vt.signatures[0];
-        if (!sig0)
+        const { transaction: tx } = (0, wire_transaction_js_1.decodeWireTransaction)(raw), msg = tx.message;
+        if (!tx.signatures[0])
             return null;
-        const signature = bs58_1.default.encode(sig0);
-        const msg = vt.message;
-        if (msg instanceof web3_js_1.MessageV0) {
-            const lookups = msg.addressTableLookups.map((l) => ({
-                accountKey: l.accountKey.toBase58(),
-                writableIndexes: new Uint8Array(l.writableIndexes),
-                readonlyIndexes: new Uint8Array(l.readonlyIndexes),
-            }));
-            const instructions = msg.compiledInstructions.map((ix) => ({
-                programIdIndex: ix.programIdIndex,
-                accounts: new Uint8Array(ix.accountKeyIndexes),
-                data: new Uint8Array(ix.data),
-            }));
-            return {
-                signature,
-                accounts: msg.staticAccountKeys.map((k) => k.toBase58()),
-                instructions,
-                messageVersion: "v0",
-                header: msg.header,
-                recentBlockhash: Uint8Array.from(bs58_1.default.decode(msg.recentBlockhash)),
-                addressTableLookups: lookups,
-            };
-        }
-        const m = msg;
-        const instructions = m.compiledInstructions.map((ix) => ({
-            programIdIndex: ix.programIdIndex,
-            accounts: new Uint8Array(ix.accountKeyIndexes),
-            data: new Uint8Array(ix.data),
-        }));
-        return {
-            signature,
-            accounts: m.staticAccountKeys.map((k) => k.toBase58()),
-            instructions,
-            messageVersion: "legacy",
-            header: m.header,
-            recentBlockhash: Uint8Array.from(bs58_1.default.decode(m.recentBlockhash)),
-        };
+        return { signature: tx.signatures[0], accounts: msg.accountKeys,
+            instructions: msg.instructions.map(ix => ({ programIdIndex: ix.programIdIndex, accounts: Uint8Array.from(ix.accounts), data: bs58_1.default.decode(ix.data) })),
+            messageVersion: tx.version === 'legacy' ? 'legacy' : tx.version === 0 ? 'v0' : 'v1', header: msg.header,
+            recentBlockhash: bs58_1.default.decode(msg.recentBlockhash),
+            addressTableLookups: msg.addressTableLookups.map(l => ({ ...l, writableIndexes: Uint8Array.from(l.writableIndexes), readonlyIndexes: Uint8Array.from(l.readonlyIndexes) })) };
     }
     catch {
         return null;

package/dist/simulation_route.d.ts

@@ -0,0 +1,6 @@
+import { type TransactionRoute } from "./transaction_route.js";
+/** Original wire plus simulateTransaction response. Parsed SPL transfers and ATA setup.
+ * Unsupported parsed CPI fail explicitly; raw/compiled CPI are preserved.
+ * V0 ALT requires the existing compiled route API and loadedAddresses.
+ */
+export declare function analyzeSimulationRoutes(wire: Uint8Array, response: unknown, graduatedPools?: readonly string[]): TransactionRoute;

package/dist/simulation_route.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSimulationRoutes = analyzeSimulationRoutes;
+/** Explicit simulation evidence adapter. No RPC or transaction reserialization. */
+const bs58_1 = __importDefault(require("bs58"));
+const wire_transaction_js_1 = require("./wire_transaction.js");
+const transaction_route_js_1 = require("./transaction_route.js");
+function unsigned(value, bits) {
+    if (typeof value === "number" && !Number.isSafeInteger(value))
+        throw Error("Unsafe simulation integer");
+    if ((typeof value !== "number" && typeof value !== "string") ||
+        !/^[0-9]+$/.test(String(value)))
+        throw Error("Invalid simulation integer");
+    const n = BigInt(value);
+    if (n < 0n || n >= 1n << BigInt(bits))
+        throw Error("Simulation integer outside range");
+    return n;
+}
+/** Original wire plus simulateTransaction response. Parsed SPL transfers and ATA setup.
+ * Unsupported parsed CPI fail explicitly; raw/compiled CPI are preserved.
+ * V0 ALT requires the existing compiled route API and loadedAddresses.
+ */
+function analyzeSimulationRoutes(wire, response, graduatedPools = []) {
+    const tx = (0, wire_transaction_js_1.decodeWireTransaction)(wire).transaction;
+    if (tx.message.addressTableLookups.length)
+        throw Error("V0 ALT addresses unavailable; use compiled route input with loadedAddresses");
+    const root = response, value = root?.result?.value;
+    if (root?.error ||
+        !value ||
+        typeof value !== "object" ||
+        !("err" in value) ||
+        !("innerInstructions" in value))
+        throw Error("Simulation response missing execution metadata");
+    if (value.innerInstructions !== null &&
+        !Array.isArray(value.innerInstructions))
+        throw Error("Invalid simulation inner instructions");
+    const keys = tx.message.accountKeys;
+    const index = (key) => {
+        if (typeof key !== "string")
+            throw Error("Missing simulation account key");
+        const n = keys.indexOf(key);
+        if (n < 0)
+            throw Error("Simulation account absent from transaction");
+        return n;
+    };
+    const validIndex = (n) => {
+        if (typeof n !== "number" ||
+            !Number.isInteger(n) ||
+            n < 0 ||
+            n >= keys.length)
+            throw Error("Invalid simulation account index");
+        return n;
+    };
+    const seen = new Set();
+    const groups = (value.innerInstructions ?? []).map((group) => {
+        if (!group ||
+            typeof group !== "object" ||
+            !Number.isInteger(group.index) ||
+            group.index < 0 ||
+            group.index >= tx.message.instructions.length ||
+            seen.has(group.index) ||
+            !Array.isArray(group.instructions))
+            throw Error("Invalid simulation instruction group");
+        seen.add(group.index);
+        return {
+            index: group.index,
+            instructions: group.instructions.map((ix) => {
+                if (!ix || typeof ix !== "object")
+                    throw Error("Invalid simulation instruction");
+                if (ix.stackHeight !== undefined &&
+                    ix.stackHeight !== null &&
+                    (!Number.isInteger(ix.stackHeight) || ix.stackHeight < 2))
+                    throw Error("Invalid simulation stack height");
+                const stackHeight = ix.stackHeight ?? null;
+                if (ix.programIdIndex !== undefined) {
+                    if (ix.parsed !== undefined ||
+                        typeof ix.data !== "string" ||
+                        !Array.isArray(ix.accounts))
+                        throw Error("Invalid compiled simulation instruction");
+                    bs58_1.default.decode(ix.data);
+                    return {
+                        programIdIndex: validIndex(ix.programIdIndex),
+                        accounts: ix.accounts.map(validIndex),
+                        data: ix.data,
+                        stackHeight,
+                    };
+                }
+                const programIdIndex = index(ix.programId);
+                if (ix.parsed === undefined) {
+                    if (typeof ix.data !== "string" || !Array.isArray(ix.accounts))
+                        throw Error("Invalid raw simulation instruction");
+                    bs58_1.default.decode(ix.data);
+                    return {
+                        programIdIndex,
+                        accounts: ix.accounts.map(index),
+                        data: ix.data,
+                        stackHeight,
+                    };
+                }
+                if (!ix.parsed ||
+                    typeof ix.parsed !== "object" ||
+                    Array.isArray(ix.parsed) ||
+                    !ix.parsed.info ||
+                    typeof ix.parsed.info !== "object" ||
+                    Array.isArray(ix.parsed.info))
+                    throw Error("Unsupported parsed simulation instruction");
+                const setup = simulationAccountSetup(ix.programId, ix.parsed.type, ix.parsed.info);
+                if (setup)
+                    return {
+                        programIdIndex,
+                        accounts: setup.accounts.map(index),
+                        data: bs58_1.default.encode(setup.data),
+                        stackHeight,
+                    };
+                if (ix.programId !== transaction_route_js_1.TOKEN && ix.programId !== transaction_route_js_1.TOKEN_2022)
+                    throw Error("Unsupported parsed simulation program");
+                const { type, info } = ix.parsed;
+                if (!info ||
+                    !["transfer", "transferChecked", "transferCheckedWithFee"].includes(type))
+                    throw Error("Unsupported parsed simulation instruction");
+                const authority = info.authority ?? info.multisigAuthority, signers = info.signers ?? [];
+                if (!Array.isArray(signers))
+                    throw Error("Invalid simulation signers");
+                let accounts, data;
+                if (type === "transfer") {
+                    accounts = [info.source, info.destination, authority, ...signers];
+                    data = Buffer.alloc(9);
+                    data[0] = 3;
+                    data.writeBigUInt64LE(unsigned(info.amount, 64), 1);
+                }
+                else {
+                    const withFee = type === "transferCheckedWithFee";
+                    if (withFee && ix.programId !== transaction_route_js_1.TOKEN_2022)
+                        throw Error("Transfer fee requires Token-2022");
+                    if (!info.tokenAmount ||
+                        typeof info.tokenAmount !== "object" ||
+                        Array.isArray(info.tokenAmount))
+                        throw Error("Invalid simulation token amount");
+                    const amount = unsigned(info.tokenAmount?.amount, 64), decimals = Number(unsigned(info.tokenAmount?.decimals, 8));
+                    accounts = [
+                        info.source,
+                        info.mint,
+                        info.destination,
+                        authority,
+                        ...signers,
+                    ];
+                    data = Buffer.alloc(withFee ? 19 : 10);
+                    if (withFee) {
+                        data[0] = 26;
+                        data[1] = 1;
+                        data.writeBigUInt64LE(amount, 2);
+                        data[10] = decimals;
+                        data.writeBigUInt64LE(unsigned(info.feeAmount, 64), 11);
+                    }
+                    else {
+                        data[0] = 12;
+                        data.writeBigUInt64LE(amount, 1);
+                        data[9] = decimals;
+                    }
+                }
+                return {
+                    programIdIndex,
+                    accounts: accounts.map(index),
+                    data: bs58_1.default.encode(data),
+                    stackHeight,
+                };
+            }),
+        };
+    });
+    return (0, transaction_route_js_1.analyzeRpcTransactionRoutes)({ transaction: tx, meta: { ...value, innerInstructions: groups } }, graduatedPools);
+}
+/** Reconstruct only understood setup layouts; extension names are deliberately bounded. */
+function simulationAccountSetup(program, type, info) {
+    const pubkey = (key) => {
+        if (typeof key !== "string")
+            throw Error("Invalid simulation public key");
+        const bytes = Buffer.from(bs58_1.default.decode(key));
+        if (bytes.length !== 32)
+            throw Error("Invalid simulation public key");
+        return bytes;
+    };
+    if (program === transaction_route_js_1.ZERO && type === "createAccount") {
+        const data = Buffer.alloc(52);
+        data.writeBigUInt64LE(unsigned(info.lamports, 64), 4);
+        data.writeBigUInt64LE(unsigned(info.space, 64), 12);
+        pubkey(info.owner).copy(data, 20);
+        return { accounts: [info.source, info.newAccount], data };
+    }
+    if (program === transaction_route_js_1.ZERO && (type === "transfer" || type === "allocate")) {
+        const data = Buffer.alloc(12);
+        data.writeUInt32LE(type === "transfer" ? 2 : 8, 0);
+        data.writeBigUInt64LE(unsigned(type === "transfer" ? info.lamports : info.space, 64), 4);
+        return { accounts: type === "transfer" ? [info.source, info.destination] : [info.account], data };
+    }
+    if (program === transaction_route_js_1.ZERO && type === "assign") {
+        const data = Buffer.alloc(36);
+        data.writeUInt32LE(1, 0);
+        pubkey(info.owner).copy(data, 4);
+        return { accounts: [info.account], data };
+    }
+    if (program !== transaction_route_js_1.TOKEN && program !== transaction_route_js_1.TOKEN_2022)
+        return null;
+    if (typeof type === "string" && ["mintTo", "mintToChecked", "burn", "burnChecked"].includes(type)) {
+        const minting = type.startsWith("mintTo"), checked = type.endsWith("Checked");
+        const authority = minting ? (info.mintAuthority ?? info.multisigMintAuthority) : (info.authority ?? info.multisigAuthority);
+        const signers = info.signers === undefined ? [] : info.signers;
+        if (!Array.isArray(signers))
+            throw Error("Invalid simulation signers");
+        const amount = checked ? info.tokenAmount : info;
+        if (!amount || typeof amount !== "object" || Array.isArray(amount))
+            throw Error("Invalid simulation token amount");
+        const data = Buffer.alloc(checked ? 10 : 9);
+        data[0] = checked ? (minting ? 14 : 15) : (minting ? 7 : 8);
+        data.writeBigUInt64LE(unsigned(amount.amount, 64), 1);
+        if (checked)
+            data[9] = Number(unsigned(amount.decimals, 8));
+        return { accounts: [...(minting ? [info.mint, info.account] : [info.account, info.mint]), authority, ...signers], data };
+    }
+    if (type === "initializeImmutableOwner")
+        return { accounts: [info.account], data: Buffer.from([22]) };
+    if (type === "initializeAccount3")
+        return {
+            accounts: [info.account, info.mint],
+            data: Buffer.concat([Buffer.from([18]), pubkey(info.owner)]),
+        };
+    if (type === "getAccountDataSize") {
+        if (!Array.isArray(info.extensionTypes))
+            throw Error("Invalid simulation extension types");
+        const data = Buffer.alloc(1 + info.extensionTypes.length * 2);
+        data[0] = 21;
+        info.extensionTypes.forEach((extension, i) => {
+            if (extension !== "immutableOwner")
+                throw Error("Unsupported simulation extension type");
+            data.writeUInt16LE(7, 1 + 2 * i);
+        });
+        return { accounts: [info.mint], data };
+    }
+    return null;
+}

package/dist/stonkfun_registry.d.ts

@@ -0,0 +1,30 @@
+export interface StonkFunGraduatedPool {
+    curve_pool: string;
+    pool: string;
+    base_mint: string;
+    quote_mint: string;
+    platform_config: string;
+    migration_signature: string;
+    migration_slot: bigint;
+}
+export declare class StonkFunPoolRegistry {
+    private pools;
+    constructor(entries?: Iterable<StonkFunGraduatedPool>);
+    get(pool: string): Readonly<StonkFunGraduatedPool> | undefined;
+    verifiedCpmmPools(): string[];
+    poolsForBaseMint(mint: string): Readonly<StonkFunGraduatedPool>[];
+    toJSON(): {
+        pools: {
+            migration_slot: string;
+            curve_pool: string;
+            pool: string;
+            base_mint: string;
+            quote_mint: string;
+            platform_config: string;
+            migration_signature: string;
+        }[];
+    };
+    static fromJSON(data: ReturnType<StonkFunPoolRegistry["toJSON"]>): StonkFunPoolRegistry;
+    observeMigrations(entries: Iterable<StonkFunGraduatedPool>, succeeded: boolean): number;
+    observeRpcTransaction(transaction: unknown): number;
+}

package/dist/stonkfun_registry.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StonkFunPoolRegistry = void 0;
+/** Caller-owned migration provenance; transactions never mutate a global registry. */
+const bs58_1 = __importDefault(require("bs58"));
+const wire_transaction_js_1 = require("./wire_transaction.js");
+const transaction_route_js_1 = require("./transaction_route.js");
+function validate(p) {
+    if (!(0, transaction_route_js_1.stonkfunModeFromPlatformConfig)(p.platform_config) ||
+        p.curve_pool === p.pool ||
+        p.base_mint === p.quote_mint)
+        throw new Error("Invalid StonkFun registry identity");
+    for (const key of [p.curve_pool, p.pool, p.base_mint, p.quote_mint])
+        if (key === transaction_route_js_1.ZERO || bs58_1.default.decode(key).length !== 32)
+            throw new Error("Invalid registry key");
+    if (bs58_1.default.decode(p.migration_signature).length !== 64 ||
+        typeof p.migration_slot !== "bigint" ||
+        p.migration_slot < 0n ||
+        p.migration_slot >= 1n << 64n)
+        throw new Error("Invalid migration provenance");
+}
+const equal = (a, b) => Object.keys(a).every((k) => a[k] ===
+    b[k]);
+class StonkFunPoolRegistry {
+    pools = new Map();
+    constructor(entries = []) {
+        for (const p of entries) {
+            validate(p);
+            if (this.pools.has(p.pool))
+                throw new Error("Duplicate registry entry");
+            this.pools.set(p.pool, Object.freeze({ ...p }));
+        }
+    }
+    get(pool) {
+        return this.pools.get(pool);
+    }
+    verifiedCpmmPools() {
+        return [...this.pools.keys()].sort();
+    }
+    poolsForBaseMint(mint) {
+        return this.verifiedCpmmPools()
+            .map((k) => this.pools.get(k))
+            .filter((p) => p.base_mint === mint);
+    }
+    toJSON() {
+        return {
+            pools: this.verifiedCpmmPools().map((k) => ({
+                ...this.pools.get(k),
+                migration_slot: this.pools.get(k).migration_slot.toString(),
+            })),
+        };
+    }
+    static fromJSON(data) {
+        return new StonkFunPoolRegistry(data.pools.map((p) => ({
+            ...p,
+            migration_slot: BigInt(p.migration_slot),
+        })));
+    }
+    observeMigrations(entries, succeeded) {
+        if (!succeeded)
+            return 0;
+        const pending = new Map();
+        for (const p of entries) {
+            validate(p);
+            const prior = pending.get(p.pool) ?? this.pools.get(p.pool);
+            if (prior && !equal(prior, p))
+                throw new Error("Conflicting migration provenance");
+            pending.set(p.pool, p);
+        }
+        let count = 0;
+        for (const [k, p] of pending) {
+            if (!this.pools.has(k))
+                count++;
+            this.pools.set(k, Object.freeze({ ...p }));
+        }
+        return count;
+    }
+    observeRpcTransaction(transaction) {
+        const root = transaction, tx = root.result ?? root;
+        if (!tx.meta || typeof tx.meta !== "object")
+            throw new Error("Transaction metadata missing");
+        if (!("err" in tx.meta))
+            throw new Error("Transaction execution status missing");
+        if (tx.meta.err !== null)
+            return 0;
+        // Use the same compiled index/group validation as route analysis.
+        (0, transaction_route_js_1.analyzeRpcTransactionRoutes)(transaction);
+        let body = tx.transaction;
+        if (Array.isArray(body)) {
+            if (body.length !== 2 || body[1] !== "base64")
+                throw new Error("Expected base64 encoding");
+            body = (0, wire_transaction_js_1.decodeWireTransaction)(Buffer.from(body[0], "base64")).transaction;
+        }
+        const loaded = tx.meta.loadedAddresses ?? {}, keys = [
+            ...body.message.accountKeys.map((k) => typeof k === "string" ? k : k.pubkey),
+            ...(loaded.writable ?? []),
+            ...(loaded.readonly ?? []),
+        ];
+        const instructions = [...body.message.instructions];
+        for (const group of tx.meta.innerInstructions ?? [])
+            instructions.push(...group.instructions);
+        const entries = [];
+        for (const ix of instructions) {
+            if (ix.programIdIndex === undefined)
+                throw new Error("Expected compiled instructions");
+            const d = typeof ix.data === "string" ? bs58_1.default.decode(ix.data) : ix.data;
+            if (keys[ix.programIdIndex] !== transaction_route_js_1.ROUTE_PROGRAMS.LaunchLab ||
+                Buffer.from(d).subarray(0, 8).toString("hex") !== "885cc8671cda908c" ||
+                ix.accounts.length < 28)
+                continue;
+            const a = Array.from(ix.accounts, (k) => keys[k] ?? transaction_route_js_1.ZERO);
+            if (a[4] !== transaction_route_js_1.ROUTE_PROGRAMS.RaydiumCpmm ||
+                !(0, transaction_route_js_1.stonkfunModeFromPlatformConfig)(a[3]))
+                continue;
+            if ([a[17], a[5], a[1], a[2]].includes(transaction_route_js_1.ZERO) ||
+                a[17] === a[5] ||
+                a[1] === a[2])
+                continue;
+            if (typeof tx.slot === "number" && !Number.isSafeInteger(tx.slot))
+                throw new Error("Unsafe slot integer");
+            entries.push({
+                curve_pool: a[17],
+                pool: a[5],
+                base_mint: a[1],
+                quote_mint: a[2],
+                platform_config: a[3],
+                migration_signature: body.signatures[0],
+                migration_slot: BigInt(tx.slot),
+            });
+        }
+        return this.observeMigrations(entries, true);
+    }
+}
+exports.StonkFunPoolRegistry = StonkFunPoolRegistry;