sol-parser-sdk-nodejs 0.3.0 → 0.4.4

package/dist/shredstream/entries_decode.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bincodeVecEntryCount = bincodeVecEntryCount;
+exports.decodeCompactU16 = decodeCompactU16;
+exports.parseTransaction = parseTransaction;
+exports.decodeEntriesBincodeFlat = decodeEntriesBincodeFlat;
+exports.decodeEntriesBincodeNested = decodeEntriesBincodeNested;
+exports.decodeShredstreamEntriesBincode = decodeShredstreamEntriesBincode;
+const wire_to_shred_tx_js_1 = require("./wire_to_shred_tx.js");
+const MAX_VEC_ENTRIES = 100_000;
+function readU64LE(buf, offset) {
+    const v = new DataView(buf.buffer, buf.byteOffset + offset, 8);
+    return v.getBigUint64(0, true);
+}
+/** 与 Go `BincodeVecEntryCount` 一致 */
+function bincodeVecEntryCount(entriesBytes) {
+    if (entriesBytes.length < 8) {
+        throw new Error("shredstream: entries payload too short for vec length");
+    }
+    const n = readU64LE(entriesBytes, 0);
+    if (n > BigInt(MAX_VEC_ENTRIES)) {
+        throw new Error(`shredstream: corrupt entry_count ${n} exceeds limit`);
+    }
+    return n;
+}
+/** compact-u16，与 Go `decodeCompactU16` 一致 */
+function decodeCompactU16(buf, pos) {
+    if (pos >= buf.length)
+        return null;
+    const b0 = buf[pos];
+    if (b0 < 0x80)
+        return { value: b0, bytes: 1 };
+    if (pos + 1 >= buf.length)
+        return null;
+    const b1 = buf[pos + 1];
+    if (b1 < 0x80) {
+        return { value: (b0 & 0x7f) | (b1 << 7), bytes: 2 };
+    }
+    if (pos + 2 >= buf.length)
+        return null;
+    const b2 = buf[pos + 2];
+    return { value: (b0 & 0x7f) | ((b1 & 0x7f) << 7) | (b2 << 14), bytes: 3 };
+}
+/** 返回 (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;
+    }
+    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)
+        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);
+    expectedEntryCount = 0;
+    entriesYielded = 0;
+    cursor = 0;
+    append(payload) {
+        const merged = new Uint8Array(this.buffer.length + payload.length);
+        merged.set(this.buffer);
+        merged.set(payload, this.buffer.length);
+        this.buffer = merged;
+    }
+    tryDecodeEntry() {
+        const pos = this.cursor;
+        const buf = this.buffer;
+        if (pos + 48 > buf.length)
+            return null;
+        let p = pos + 8 + 32;
+        const txCount = Number(readU64LE(buf, p));
+        p += 8;
+        const txs = [];
+        for (let i = 0; i < txCount; i++) {
+            const txStart = p;
+            const parsed = parseTransaction(buf, p);
+            if (!parsed) {
+                throw new Error(`shredstream: truncated transaction ${i} in entry`);
+            }
+            const { txLen, sigs } = parsed;
+            const raw = buf.subarray(txStart, txStart + txLen);
+            txs.push({
+                raw: Uint8Array.from(raw),
+                signatures: sigs.map((s) => Uint8Array.from(s)),
+            });
+            p = txStart + txLen;
+        }
+        this.cursor = p;
+        return txs;
+    }
+    /** 扁平列表，对齐 Go `DecodeEntriesBincode` */
+    pushFlat(payload) {
+        this.append(payload);
+        if (this.expectedEntryCount === 0 && this.entriesYielded === 0 && this.cursor === 0) {
+            if (this.buffer.length < 8) {
+                throw new Error("shredstream: entries payload too short for vec length");
+            }
+            const count = readU64LE(this.buffer, 0);
+            if (count > BigInt(MAX_VEC_ENTRIES)) {
+                throw new Error(`shredstream: corrupt entry_count ${count} exceeds limit`);
+            }
+            this.expectedEntryCount = Number(count);
+            this.cursor = 8;
+        }
+        const out = [];
+        while (this.entriesYielded < this.expectedEntryCount) {
+            const entryTxs = this.tryDecodeEntry();
+            if (entryTxs === null) {
+                throw new Error(`shredstream: incomplete entry at offset ${this.cursor}`);
+            }
+            out.push(...entryTxs);
+            this.entriesYielded++;
+        }
+        return out;
+    }
+    /** 按 Solana `Entry` 分层，供 ShredStream 客户端（Entry 内 tx_index） */
+    pushNested(payload) {
+        this.append(payload);
+        if (this.expectedEntryCount === 0 && this.entriesYielded === 0 && this.cursor === 0) {
+            if (this.buffer.length < 8) {
+                throw new Error("shredstream: entries payload too short for vec length");
+            }
+            const count = readU64LE(this.buffer, 0);
+            if (count > BigInt(MAX_VEC_ENTRIES)) {
+                throw new Error(`shredstream: corrupt entry_count ${count} exceeds limit`);
+            }
+            this.expectedEntryCount = Number(count);
+            this.cursor = 8;
+        }
+        const nested = [];
+        while (this.entriesYielded < this.expectedEntryCount) {
+            const entryTxs = this.tryDecodeEntry();
+            if (entryTxs === null) {
+                throw new Error(`shredstream: incomplete entry at offset ${this.cursor}`);
+            }
+            nested.push(entryTxs);
+            this.entriesYielded++;
+        }
+        return nested;
+    }
+}
+function decodeEntriesBincodeFlat(entriesBytes) {
+    if (entriesBytes.length === 0)
+        return [];
+    const dec = new BatchDecoder();
+    return dec.pushFlat(entriesBytes);
+}
+function decodeEntriesBincodeNested(entriesBytes) {
+    if (entriesBytes.length === 0)
+        return [];
+    const dec = new BatchDecoder();
+    return dec.pushNested(entriesBytes);
+}
+/**
+ * 解码 gRPC `entries` 字节并展开为与旧 WASM 相同的嵌套 `ShredWasmTx`（跳过无法反序列化的单笔交易）。
+ */
+function decodeShredstreamEntriesBincode(bytes) {
+    const nested = decodeEntriesBincodeNested(bytes);
+    const out = [];
+    for (const entryTxs of nested) {
+        const row = [];
+        for (const w of entryTxs) {
+            const tx = (0, wire_to_shred_tx_js_1.wireBytesToShredWasmTx)(w.raw);
+            if (tx)
+                row.push(tx);
+        }
+        out.push(row);
+    }
+    return out;
+}

package/dist/shredstream/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Jito ShredStream 超低延迟订阅（与 Rust `sol-parser-sdk::shredstream` 对齐）。
+ *
+ * 限制（与 Rust `shredstream/mod.rs` 文档一致）：
+ * - 仅静态账户键；使用 ALT 的交易账户列表不完整
+ * - 无 inner instructions，无法 CPI 解析
+ * - 无 block_time
+ * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则跳过该指令）
+ * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
+ */
+export { type ShredStreamConfig, defaultShredStreamConfig, lowLatencyShredStreamConfig, highThroughputShredStreamConfig, } from "./config.js";
+export { ShredStreamClient, ShredEventQueue, type ShredStreamReceiveStats, } from "./client.js";
+export { dexEventsFromShredWasmTx, dexEventsFromShredWasmTxWithFullKeys, type ShredWasmTx, type ShredWasmCompiledIx, } from "./instruction_parse.js";
+export { fullAccountKeyStringsFromShredTx, loadAddressLookupTableAccounts } from "./alt_lookup.js";
+export type { SubscribeEntriesRequest, ShredstreamEntryMessage } from "./proto_types.js";
+export { bincodeVecEntryCount, decodeEntriesBincodeFlat, decodeEntriesBincodeNested, decodeShredstreamEntriesBincode, type DecodedWireTransaction, } from "./entries_decode.js";
+export { wireBytesToShredWasmTx } from "./wire_to_shred_tx.js";

package/dist/shredstream/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireBytesToShredWasmTx = exports.decodeShredstreamEntriesBincode = exports.decodeEntriesBincodeNested = exports.decodeEntriesBincodeFlat = exports.bincodeVecEntryCount = exports.loadAddressLookupTableAccounts = exports.fullAccountKeyStringsFromShredTx = exports.dexEventsFromShredWasmTxWithFullKeys = exports.dexEventsFromShredWasmTx = exports.ShredEventQueue = exports.ShredStreamClient = exports.highThroughputShredStreamConfig = exports.lowLatencyShredStreamConfig = exports.defaultShredStreamConfig = void 0;
+/**
+ * Jito ShredStream 超低延迟订阅（与 Rust `sol-parser-sdk::shredstream` 对齐）。
+ *
+ * 限制（与 Rust `shredstream/mod.rs` 文档一致）：
+ * - 仅静态账户键；使用 ALT 的交易账户列表不完整
+ * - 无 inner instructions，无法 CPI 解析
+ * - 无 block_time
+ * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则跳过该指令）
+ * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
+ */
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "defaultShredStreamConfig", { enumerable: true, get: function () { return config_js_1.defaultShredStreamConfig; } });
+Object.defineProperty(exports, "lowLatencyShredStreamConfig", { enumerable: true, get: function () { return config_js_1.lowLatencyShredStreamConfig; } });
+Object.defineProperty(exports, "highThroughputShredStreamConfig", { enumerable: true, get: function () { return config_js_1.highThroughputShredStreamConfig; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "ShredStreamClient", { enumerable: true, get: function () { return client_js_1.ShredStreamClient; } });
+Object.defineProperty(exports, "ShredEventQueue", { enumerable: true, get: function () { return client_js_1.ShredEventQueue; } });
+var instruction_parse_js_1 = require("./instruction_parse.js");
+Object.defineProperty(exports, "dexEventsFromShredWasmTx", { enumerable: true, get: function () { return instruction_parse_js_1.dexEventsFromShredWasmTx; } });
+Object.defineProperty(exports, "dexEventsFromShredWasmTxWithFullKeys", { enumerable: true, get: function () { return instruction_parse_js_1.dexEventsFromShredWasmTxWithFullKeys; } });
+var alt_lookup_js_1 = require("./alt_lookup.js");
+Object.defineProperty(exports, "fullAccountKeyStringsFromShredTx", { enumerable: true, get: function () { return alt_lookup_js_1.fullAccountKeyStringsFromShredTx; } });
+Object.defineProperty(exports, "loadAddressLookupTableAccounts", { enumerable: true, get: function () { return alt_lookup_js_1.loadAddressLookupTableAccounts; } });
+var entries_decode_js_1 = require("./entries_decode.js");
+Object.defineProperty(exports, "bincodeVecEntryCount", { enumerable: true, get: function () { return entries_decode_js_1.bincodeVecEntryCount; } });
+Object.defineProperty(exports, "decodeEntriesBincodeFlat", { enumerable: true, get: function () { return entries_decode_js_1.decodeEntriesBincodeFlat; } });
+Object.defineProperty(exports, "decodeEntriesBincodeNested", { enumerable: true, get: function () { return entries_decode_js_1.decodeEntriesBincodeNested; } });
+Object.defineProperty(exports, "decodeShredstreamEntriesBincode", { enumerable: true, get: function () { return entries_decode_js_1.decodeShredstreamEntriesBincode; } });
+var wire_to_shred_tx_js_1 = require("./wire_to_shred_tx.js");
+Object.defineProperty(exports, "wireBytesToShredWasmTx", { enumerable: true, get: function () { return wire_to_shred_tx_js_1.wireBytesToShredWasmTx; } });

package/dist/shredstream/instruction_parse.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ShredStream：外层编译指令 → `parseInstructionUnified`（与 gRPC 指令解析同源）。
+ * `ShredWasmTx` 来自线格式交易经 `@solana/web3.js` 反序列化（见 `wire_to_shred_tx.ts`），非 WASM。
+ * 完整账户列表需含 V0 ALT 展开，见 `alt_lookup.ts` + `ShredStreamConfig.connection`。
+ */
+import type { MessageHeader } from "@solana/web3.js";
+import type { DexEvent } from "../core/dex_event.js";
+import type { EventTypeFilter } from "../grpc/types.js";
+export type ShredWasmCompiledIx = {
+    programIdIndex: number;
+    accounts: Uint8Array;
+    data: Uint8Array;
+};
+export type ShredAddressTableLookup = {
+    accountKey: string;
+    writableIndexes: Uint8Array;
+    readonlyIndexes: Uint8Array;
+};
+export type ShredWasmTx = {
+    signature: string;
+    accounts: string[];
+    instructions?: ShredWasmCompiledIx[];
+    /** 缺省则按仅静态账户处理 */
+    messageVersion?: "legacy" | "v0";
+    header?: MessageHeader;
+    recentBlockhash?: Uint8Array;
+    addressTableLookups?: ShredAddressTableLookup[];
+};
+/**
+ * 使用已解析的完整账户表（静态+ALT）解析外层指令。
+ */
+export declare function dexEventsFromShredWasmTxWithFullKeys(tx: ShredWasmTx, fullAccountKeys: string[], slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];
+/** 仅静态账户表（无 RPC 时；V0+ALT 交易多数指令无法解析） */
+export declare function dexEventsFromShredWasmTx(tx: ShredWasmTx, slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];

package/dist/shredstream/instruction_parse.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dexEventsFromShredWasmTxWithFullKeys = dexEventsFromShredWasmTxWithFullKeys;
+exports.dexEventsFromShredWasmTx = dexEventsFromShredWasmTx;
+const pumpfun_fee_enrich_js_1 = require("../core/pumpfun_fee_enrich.js");
+const mod_js_1 = require("../instr/mod.js");
+function asU8(b) {
+    if (b instanceof Uint8Array)
+        return b;
+    return Uint8Array.from(b);
+}
+/**
+ * 使用已解析的完整账户表（静态+ALT）解析外层指令。
+ */
+function dexEventsFromShredWasmTxWithFullKeys(tx, fullAccountKeys, slot, txIndex, grpcRecvUs, eventTypeFilter) {
+    const ixs = tx.instructions;
+    if (!ixs?.length || fullAccountKeys.length === 0)
+        return [];
+    const out = [];
+    for (const rawIx of ixs) {
+        const pidIdx = rawIx.programIdIndex;
+        if (!Number.isFinite(pidIdx) || pidIdx < 0 || pidIdx >= fullAccountKeys.length)
+            continue;
+        const programId = fullAccountKeys[pidIdx];
+        const accBytes = asU8(rawIx.accounts);
+        const data = asU8(rawIx.data);
+        const accountStrs = [];
+        let oob = false;
+        for (let i = 0; i < accBytes.length; i++) {
+            const ai = accBytes[i];
+            if (ai >= fullAccountKeys.length) {
+                oob = true;
+                break;
+            }
+            accountStrs.push(fullAccountKeys[ai]);
+        }
+        if (oob)
+            continue;
+        const ev = (0, mod_js_1.parseInstructionUnified)(data, accountStrs, tx.signature, slot, txIndex, undefined, grpcRecvUs, eventTypeFilter, programId);
+        if (ev)
+            out.push(ev);
+    }
+    (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(out);
+    return out;
+}
+/** 仅静态账户表（无 RPC 时；V0+ALT 交易多数指令无法解析） */
+function dexEventsFromShredWasmTx(tx, slot, txIndex, grpcRecvUs, eventTypeFilter) {
+    return dexEventsFromShredWasmTxWithFullKeys(tx, tx.accounts, slot, txIndex, grpcRecvUs, eventTypeFilter);
+}

package/dist/shredstream/proto_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ShredStream gRPC 消息形状（与 Rust `shredstream::proto` 中 prost 定义一致）。
+ * 实际线路仍由 `shredstream.proto` + `@grpc/proto-loader` 解析。
+ */
+export type SubscribeEntriesRequest = Record<string, never>;
+export interface ShredstreamEntryMessage {
+    slot: number | string | bigint;
+    entries: Uint8Array | Buffer;
+}

package/dist/shredstream/proto_types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shredstream/shredstream.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package shredstream;
+
+// 与 Rust `shredstream/proto/mod.rs` 内嵌定义一致；路径 /shredstream.ShredstreamProxy/SubscribeEntries
+service ShredstreamProxy {
+  rpc SubscribeEntries(SubscribeEntriesRequest) returns (stream Entry);
+}
+
+message SubscribeEntriesRequest {}
+
+message Entry {
+  uint64 slot = 1;
+  bytes entries = 2;
+}

package/dist/shredstream/wire_to_shred_tx.d.ts

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

package/dist/shredstream/wire_to_shred_tx.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wireBytesToShredWasmTx = wireBytesToShredWasmTx;
+/**
+ * 线格式交易字节 → `ShredWasmTx`（与原 wasm-pack 展开字段对齐，供 `parseInstructionUnified`）。
+ */
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+function wireBytesToShredWasmTx(raw) {
+    try {
+        const vt = web3_js_1.VersionedTransaction.deserialize(Buffer.from(raw));
+        const sig0 = vt.signatures[0];
+        if (!sig0)
+            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)),
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol-parser-sdk-nodejs",
-  "version": "0.3.0",
+  "version": "0.4.4",
   "description": "High-performance Solana DEX event parser for Node.js/TypeScript (Yellowstone gRPC, log parsing)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,8 @@
     "dist",
     "README.md",
     "README_CN.md",
-    "LICENSE"
+    "LICENSE",
+    ".env.example"
   ],
   "repository": {
     "type": "git",
@@ -22,21 +23,37 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && mkdir -p dist/shredstream && cp src/shredstream/shredstream.proto dist/shredstream/",
     "prepublishOnly": "npm run build",
-    "test:grpc": "node scripts/test-grpc-ts.mjs",
-    "debug:grpc": "node scripts/debug-grpc-ts.mjs",
-    "check:dex-events": "node scripts/check-dex-event-parity.mjs",
-    "verify:discriminators": "node scripts/verify-program-log-discriminators.mjs",
-    "check:json-utils": "node scripts/check-json-utils.mjs",
-    "check:migration": "npm run build && npm run check:dex-events && npm run verify:discriminators && npm run check:json-utils"
+    "check:dex-events": "tsx scripts/check-dex-event-parity.ts",
+    "verify:discriminators": "tsx scripts/verify-program-log-discriminators.ts",
+    "check:json-utils": "tsx scripts/check-json-utils.ts",
+    "check:discriminator-lut": "tsx scripts/check-discriminator-lut.ts",
+    "test": "vitest run",
+    "check:migration": "npm run check:dex-events && npm run verify:discriminators && npm run check:discriminator-lut && npm run check:json-utils && npm run build",
+    "example:shredstream:subscribe": "tsx examples/shredstream_example.ts",
+    "example:shredstream:pumpfun-json": "tsx examples/shredstream_pumpfun_json.ts",
+    "example:shredstream": "tsx examples/shredstream_example.ts",
+    "example:shredstream:pumpfun": "tsx examples/shredstream_pumpfun_json.ts"
   },
-  "keywords": ["solana", "dex", "parser", "pumpfun", "raydium"],
+  "keywords": [
+    "solana",
+    "dex",
+    "parser",
+    "pumpfun",
+    "raydium"
+  ],
   "license": "MIT",
   "devDependencies": {
-    "typescript": "^5.6.3"
+    "@types/node": "^22.19.17",
+    "dotenv": "^17.4.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.9"
   },
   "dependencies": {
+    "@grpc/grpc-js": "^1.12.4",
+    "@grpc/proto-loader": "^0.7.13",
     "@solana/web3.js": "^1.95.4",
     "@triton-one/yellowstone-grpc": "^1.0.0",
     "bs58": "^6.0.0"