sol-parser-sdk 0.5.15 → 0.5.17

package/dist/rpc_transaction.d.ts

@@ -13,9 +13,10 @@ export declare function applyAccountFillsToLogEvents(events: DexEvent[], msg: Me
  * 解析已获取的 `VersionedTransactionResponse`（顺序：指令 → 日志 → 账户/数据填充）。
  */
 export declare function parseRpcTransaction(tx: VersionedTransactionResponse, signature: string, filter?: EventTypeFilter, options?: {
-    grpcRecvUs?: number;
-    txIndex?: number;
-    blockTimeUs?: number;
+    slot?: bigint | string | number;
+    grpcRecvUs?: bigint | string | number;
+    txIndex?: bigint | string | number;
+    blockTimeUs?: bigint | string | number;
 }): {
     ok: true;
     events: DexEvent[];

package/dist/rpc_transaction.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fillDataRpc = exports.fillAccountsFromTransactionDataRpc = void 0;
 exports.applyAccountFillsToLogEvents = applyAccountFillsToLogEvents;
 exports.parseRpcTransaction = parseRpcTransaction;
+const metadata_js_1 = require("./core/metadata.js");
 /**
  * RPC 交易解析：外层 + 内层指令 → 日志 → `fillAccountsFromTransactionDataRpc` → `fillDataRpc`。
  */
@@ -472,6 +473,9 @@ function applyAccountFillsToLogEvents(events, msg, meta) {
  * 解析已获取的 `VersionedTransactionResponse`（顺序：指令 → 日志 → 账户/数据填充）。
  */
 function parseRpcTransaction(tx, signature, filter, options) {
+    // Failed transactions roll back every instruction, including earlier create logs.
+    if (tx.meta?.err != null)
+        return { ok: true, events: [] };
     const msg = tx.transaction?.message;
     if (!msg || !(0, rpc_invoke_map_js_1.isCompiledVersionedMessage)(msg)) {
         return {
@@ -483,8 +487,8 @@ function parseRpcTransaction(tx, signature, filter, options) {
         };
     }
     const meta = tx.meta ?? null;
-    const slot = tx.slot;
-    const blockTimeUs = options?.blockTimeUs ?? (tx.blockTime != null ? tx.blockTime * 1_000_000 : undefined);
+    const slot = (0, metadata_js_1.exactU64)(options?.slot ?? tx.slot, "slot");
+    const blockTimeUs = options?.blockTimeUs ?? (tx.blockTime != null ? (0, metadata_js_1.exactI64)(tx.blockTime) * 1000000n : undefined);
     const grpcRecvUs = options?.grpcRecvUs ?? Math.floor(Date.now() * 1000);
     const txIndex = options?.txIndex ?? 0;
     const rb = recentBlockhashBytes(msg.recentBlockhash);

package/dist/shredstream/client.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShredStreamClient = exports.ShredEventQueue = void 0;
+const metadata_js_1 = require("../core/metadata.js");
 /**
  * ShredStream 客户端：与 Rust `shredstream/client.rs` 对齐（gRPC + bincode 解码 + `parseTransactionEvents`）。
  */
@@ -120,7 +121,7 @@ function setGrpcRecvUsMut(event, grpcRecvUs) {
         return;
     const inner = event[key];
     if (inner?.metadata)
-        inner.metadata.grpc_recv_us = grpcRecvUs;
+        inner.metadata.grpc_recv_us = (0, metadata_js_1.exactI64)(grpcRecvUs);
 }
 class ShredStreamClient {
     endpoint;
@@ -394,10 +395,5 @@ class ShredStreamClient {
 }
 exports.ShredStreamClient = ShredStreamClient;
 function toSlotNumber(slot) {
-    if (typeof slot === "number")
-        return slot;
-    if (typeof slot === "bigint")
-        return Number(slot);
-    const n = Number(slot);
-    return Number.isFinite(n) ? Math.floor(n) : 0;
+    return (0, metadata_js_1.exactU64)(slot, "ShredStream slot");
 }

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;
+}