sol-parser-sdk 0.5.11 → 0.5.13

package/README.md

@@ -75,7 +75,7 @@
 **From npm**
 
 ```bash
-npm install sol-parser-sdk@0.5.11
+npm install sol-parser-sdk@0.5.13
 ```
 
 **From source** (folder may be named `sol-parser-sdk-ts` in a monorepo)
@@ -150,9 +150,10 @@ console.log("subscribed", sub.id);
 ### Long-running low-latency DEX subscriptions
 
 The public API remains queue-based, matching the Rust SDK's `subscribe_dex_events` shape. The Node
-subscription is an async iterable instead of Rust's `ArrayQueue`, while ring-buffer dequeue,
-Yellowstone update parsing, HTTP/2 receive-window tuning, and reconnect behavior are handled inside
-the SDK:
+subscription is an async iterable instead of Rust's `ArrayQueue`. Raw Yellowstone protobuf objects
+are mapped directly into the parser without the former protobuf/WASM/JSON/Base58 transaction
+round-trip. Ring-buffer dequeue, bounded pre-parser scheduling, HTTP/2 receive-window tuning, and
+reconnect behavior are handled inside the SDK:
 
 ```typescript
 import { YellowstoneGrpc, lowLatencyClientConfig } from "sol-parser-sdk";
@@ -170,8 +171,59 @@ for await (const event of sub) {
 ```
 
 If using `for await`, the default overflow behavior remains `drop-newest` for compatibility. A
-tip-oriented consumer can choose `queueOverflowStrategy: "drop-oldest"` and monitor `sub.len()` and
-`sub.dropped()`. Every overflow is counted and periodically reported through `sub.errors`.
+tip-oriented consumer can choose `queueOverflowStrategy: "drop-oldest"`. Monitor the public event
+queue with `sub.len()` / `sub.eventDropped()` and the pre-parser queue with
+`sub.ingressLen()` / `sub.ingressDropped()`. `sub.dropped()` is the combined count. Every overflow
+is counted and periodically reported through `sub.errors`.
+
+Automatic reconnect resumes from the last successfully parsed slot by default and deduplicates
+replayed transaction/account updates. Monitor transport continuity with `sub.isStreamConnected()`,
+`sub.streamDisconnects()`, `sub.reconnects()`, `sub.replayedUpdates()`, and
+`sub.continuityBreaks()`. A zero local drop count does not describe updates lost before the gRPC
+`data` callback. If a provider rejects Yellowstone `fromSlot`, the SDK reports the failure through
+`sub.errors`, increments `continuityBreaks()`, and reconnects live. Set `replayOnReconnect: false`
+only when duplicate-free live delivery is more important than recovering a disconnect window.
+
+For precise local-only measurements, set `config.enable_metrics = true`. Event metadata then includes
+`local_queue_latency_us`, `parse_duration_us`, and `local_processing_latency_us`. These values use
+Node's monotonic high-resolution clock. They measure only local queueing and parsing; the hot path
+does not call `getSlot`, `getTransaction`, JSON-RPC, or any unary RPC method.
+
+`local_processing_latency_us` is the end-to-end local metric: it starts at entry to Yellowstone's
+gRPC `data` callback and ends immediately after complete event parsing and field filling.
+
+Full-volume PumpFun and PumpSwap can use the same Rust-aligned program filter. Yellowstone applies
+`account_include` as ANY, so this receives every transaction containing either supported program:
+
+```typescript
+const allPumpTransactions = transactionFilterForProtocols(["PumpFun", "PumpSwap"]);
+const sub = await client.subscribeDexEvents([allPumpTransactions], [], eventTypeFilter);
+```
+
+`eventTypeFilter` avoids unnecessary event decoding, but it does not reduce traffic sent by
+Yellowstone. When an application intentionally needs only selected mints, pools, or users, the
+optional scoped filter requires the protocol program and any one tracked account:
+
+```typescript
+const pumpSwap = transactionFilterForProtocolAccounts("PumpSwap", knownMintsAndPools);
+const sub = await client.subscribeDexEvents(
+  [transactionFilterForProtocols(["PumpFun"]), pumpSwap],
+  [],
+  eventTypeFilter
+);
+```
+
+The combined example uses full-volume PumpSwap by default. Set `PUMPSWAP_FILTER_MODE=scoped` only when
+scoped monitoring is desired; in that mode `updateSubscription()` refreshes the active account
+filters. `PumpSwapCreatePool` maps a known base or quote mint to its pool, and
+`PumpSwapLiquidityAdded` can then be compared with the developer associated with that mint.
+
+Two `YellowstoneGrpc` instances in one Node process still share one JavaScript event loop. The direct
+protobuf path supports full PumpFun + PumpSwap in one subscription; use a separate OS process or
+Worker Thread only when application callbacks, database work, or additional protocols saturate that
+event loop. A separate gRPC connection alone does not provide CPU isolation. Send database work to a
+bounded handoff queue and batch asynchronous SQLite WAL writes; do not await one write per event in
+the subscription loop.
 
 No bounded in-memory stream can guarantee both zero loss and bounded latency when the consumer's
 average processing rate is below the filtered input rate. Keep the loop body CPU-light, avoid
@@ -205,6 +257,7 @@ From the **package root** after `npm install`. Examples use `npx tsx` and load `
 | Debug: print `metaRaw` / log structure | `npx tsx scripts/debug-grpc-ts.ts` | [debug-grpc-ts.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/scripts/debug-grpc-ts.ts) |
 | **PumpFun** | | |
 | CREATE + dev BUY/SELL, long-running low latency | `npx tsx examples/devtrades_low_latency.ts` | [devtrades_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/devtrades_low_latency.ts) |
+| PumpFun + full-volume PumpSwap dev trades/liquidity | `npm run example:grpc:devtrades:pumpswap` | [devtrades_pumpfun_pumpswap_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/devtrades_pumpfun_pumpswap_low_latency.ts) |
 | Pretty-print full JSON `DexEvent` over gRPC | `npx tsx examples/pumpfun_grpc_json.ts` | [pumpfun_grpc_json.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpfun_grpc_json.ts) |
 | PumpFun events + metrics | `npx tsx examples/pumpfun_with_metrics.ts` | [pumpfun_with_metrics.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpfun_with_metrics.ts) |
 | PumpFun trade filter | `npx tsx examples/pumpfun_trade_filter.ts` | [pumpfun_trade_filter.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpfun_trade_filter.ts) |
@@ -212,7 +265,7 @@ From the **package root** after `npm install`. Examples use `npx tsx` and load `
 | **PumpSwap** | | |
 | Pretty-print full JSON `DexEvent` over gRPC | `npx tsx examples/pumpswap_grpc_json.ts` | [pumpswap_grpc_json.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_grpc_json.ts) |
 | PumpSwap events + metrics | `npx tsx examples/pumpswap_with_metrics.ts` | [pumpswap_with_metrics.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_with_metrics.ts) |
-| PumpSwap ultra-low latency | `npx tsx examples/pumpswap_low_latency.ts` | [pumpswap_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_low_latency.ts) |
+| PumpSwap swaps, pool creation, and liquidity events (ultra-low latency) | `npm run example:grpc:pumpswap` | [pumpswap_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_low_latency.ts) |
 | **Meteora DAMM** | | |
 | Meteora DAMM V2 events | `npx tsx examples/meteora_damm_grpc.ts` | [meteora_damm_grpc.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/meteora_damm_grpc.ts) |
 | **ShredStream** (HTTP, not Yellowstone gRPC; see **step 5** above) | | |

package/README_CN.md

@@ -75,7 +75,7 @@
 **npm**
 
 ```bash
-npm install sol-parser-sdk@0.5.11
+npm install sol-parser-sdk@0.5.13
 ```
 
 **源码**（monorepo 里目录可能是 `sol-parser-sdk-ts`）
@@ -150,7 +150,8 @@ console.log("subscribed", sub.id);
 ### 长时间运行的低延迟 DEX 订阅
 
 公开 API 保持队列式调用，与 Rust SDK 的 `subscribe_dex_events` 形态一致。Node 使用异步
-迭代器代替 Rust 的 `ArrayQueue`；环形队列出队、Yellowstone update 解析、HTTP/2 接收窗口
+迭代器代替 Rust 的 `ArrayQueue`。Yellowstone 原始 protobuf 对象会直接映射给解析器，不再经过
+旧的 protobuf/WASM/JSON/Base58 整笔交易往返；环形队列出队、有界解析前调度、HTTP/2 接收窗口
 和重连优化全部由 SDK 内部完成：
 
 ```typescript
@@ -169,8 +170,54 @@ for await (const event of sub) {
 ```
 
 若使用 `for await`，默认溢出策略仍是 `drop-newest`，以保持兼容。更重视贴近链尖的消费者
-可以设置 `queueOverflowStrategy: "drop-oldest"`，并监控 `sub.len()` 和 `sub.dropped()`。
-每次溢出都会计数，并定期通过 `sub.errors` 报告。
+可以设置 `queueOverflowStrategy: "drop-oldest"`。通过 `sub.len()` / `sub.eventDropped()` 监控
+公开事件队列，通过 `sub.ingressLen()` / `sub.ingressDropped()` 监控解析前入口队列；
+`sub.dropped()` 返回两者之和。每次溢出都会计数，并定期通过 `sub.errors` 报告。
+
+自动重连默认从最后一个成功解析的 slot 继续订阅，并对回放的 transaction/account update
+去重。可通过 `sub.isStreamConnected()`、`sub.streamDisconnects()`、`sub.reconnects()`、
+`sub.replayedUpdates()` 和 `sub.continuityBreaks()` 监控传输连续性。本地 drop 为零并不能说明
+进入 gRPC `data` 回调之前没有丢数据。如果 provider 拒绝 Yellowstone `fromSlot`，SDK 会通过
+`sub.errors` 明确报告，增加 `continuityBreaks()`，再降级为 live 重连。只有在“绝不接收回放重复”
+比“补偿断线窗口”更重要时，才应设置 `replayOnReconnect: false`。
+
+如需精确测量纯本地延迟，请设置 `config.enable_metrics = true`。事件 metadata 将包含
+`local_queue_latency_us`、`parse_duration_us` 和 `local_processing_latency_us`，这些字段使用
+Node 单调高精度时钟，只测量本地排队与解析。热路径不会调用 `getSlot`、`getTransaction`、
+JSON-RPC 或任何 unary RPC 方法。
+
+`local_processing_latency_us` 是本地端到端指标：从进入 Yellowstone gRPC `data` 回调开始，
+到完整事件解析和字段填充结束为止。
+
+PumpFun 与 PumpSwap 全量交易可以直接使用和 Rust 对齐的 Program ID 过滤器。Yellowstone 的
+`account_include` 是 ANY 语义，因此下面会接收包含任一协议程序的全部交易：
+
+```typescript
+const allPumpTransactions = transactionFilterForProtocols(["PumpFun", "PumpSwap"]);
+const sub = await client.subscribeDexEvents([allPumpTransactions], [], eventTypeFilter);
+```
+
+`eventTypeFilter` 可以减少无关事件解码，但不会减少 Yellowstone 发来的交易。只有应用明确只想
+监控部分 mint、pool 或 user 时，才需要下面的可选限定过滤器；它要求交易同时包含协议程序，
+并包含任意一个已跟踪账户：
+
+```typescript
+const pumpSwap = transactionFilterForProtocolAccounts("PumpSwap", knownMintsAndPools);
+const sub = await client.subscribeDexEvents(
+  [transactionFilterForProtocols(["PumpFun"]), pumpSwap],
+  [],
+  eventTypeFilter
+);
+```
+
+组合示例默认订阅全量 PumpSwap。只有设置 `PUMPSWAP_FILTER_MODE=scoped` 时才按账户限定；
+该模式会通过 `updateSubscription()` 刷新活跃账户过滤器。`PumpSwapCreatePool` 可把已知 base
+mint 或 quote mint 映射到 pool，再将 `PumpSwapLiquidityAdded.user` 与该 mint 的开发者比较。
+
+同一 Node 进程里的两个 `YellowstoneGrpc` 实例仍共享一个 JavaScript 事件循环。直接 protobuf
+路径支持在一条订阅中接收全量 PumpFun + PumpSwap；只有业务回调、数据库写入或更多协议使事件
+循环饱和时，才需要独立进程或 Worker Thread。仅拆成两条 gRPC 连接不能隔离 CPU。数据库写入
+应进入有界交接队列并异步批量写 SQLite WAL，不要在订阅循环中逐事件等待写入。
 
 当消费者平均处理速度低于过滤后的入流速度时，任何有界内存流都无法同时保证零丢失和
 有界延迟。消费循环应保持轻量，避免逐事件同步日志，在服务端尽量缩小过滤范围，并把
@@ -203,6 +250,7 @@ npx tsx examples/shredstream_example.ts -- --url=http://127.0.0.1:10800
 | 调试：打印 `metaRaw` / 日志结构 | `npx tsx scripts/debug-grpc-ts.ts` | [debug-grpc-ts.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/scripts/debug-grpc-ts.ts) |
 | **PumpFun** | | |
 | CREATE + dev BUY/SELL 长时间低延迟订阅 | `npx tsx examples/devtrades_low_latency.ts` | [devtrades_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/devtrades_low_latency.ts) |
+| PumpFun + 全量 PumpSwap 开发者交易/加池 | `npm run example:grpc:devtrades:pumpswap` | [devtrades_pumpfun_pumpswap_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/devtrades_pumpfun_pumpswap_low_latency.ts) |
 | gRPC 输出完整 JSON `DexEvent` | `npx tsx examples/pumpfun_grpc_json.ts` | [pumpfun_grpc_json.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpfun_grpc_json.ts) |
 | PumpFun 事件 + 性能指标 | `npx tsx examples/pumpfun_with_metrics.ts` | [pumpfun_with_metrics.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpfun_with_metrics.ts) |
 | PumpFun 交易类型过滤 | `npx tsx examples/pumpfun_trade_filter.ts` | [pumpfun_trade_filter.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpfun_trade_filter.ts) |
@@ -210,7 +258,7 @@ npx tsx examples/shredstream_example.ts -- --url=http://127.0.0.1:10800
 | **PumpSwap** | | |
 | gRPC 输出完整 JSON `DexEvent` | `npx tsx examples/pumpswap_grpc_json.ts` | [pumpswap_grpc_json.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_grpc_json.ts) |
 | PumpSwap 事件 + 性能指标 | `npx tsx examples/pumpswap_with_metrics.ts` | [pumpswap_with_metrics.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_with_metrics.ts) |
-| PumpSwap 超低延迟 | `npx tsx examples/pumpswap_low_latency.ts` | [pumpswap_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_low_latency.ts) |
+| PumpSwap 交易、创建池及流动性事件（超低延迟） | `npm run example:grpc:pumpswap` | [pumpswap_low_latency.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/pumpswap_low_latency.ts) |
 | **Meteora DAMM** | | |
 | Meteora DAMM V2 事件 | `npx tsx examples/meteora_damm_grpc.ts` | [meteora_damm_grpc.ts](https://github.com/0xfnzero/sol-parser-sdk-nodejs/blob/main/examples/meteora_damm_grpc.ts) |
 | **ShredStream**（HTTP，**非** Yellowstone gRPC；端点见上文步骤 5） | | |

package/dist/core/metadata.d.ts

@@ -6,6 +6,12 @@ export interface EventMetadata {
     tx_index: number;
     block_time_us: number;
     grpc_recv_us: number;
+    /** Time waiting in the local pre-parser queue, measured with a monotonic clock. */
+    local_queue_latency_us?: number;
+    /** Pure local adapter + parser duration. No network or RPC calls are included. */
+    parse_duration_us?: number;
+    /** Start of the local gRPC data callback through parser completion. No RPC calls are included. */
+    local_processing_latency_us?: number;
     recent_blockhash?: string;
 }
 export declare function makeMetadata(signature: string, slot: number, txIndex: number, blockTimeUs: number | undefined, grpcRecvUs: number, recentBlockhash?: string): EventMetadata;

package/dist/core/rpc_invoke_map.js

@@ -19,6 +19,7 @@ exports.getInstructionDataBytes = getInstructionDataBytes;
  */
 const bs58_1 = __importDefault(require("bs58"));
 const web3_js_1 = require("@solana/web3.js");
+const accountKeyBase58Cache = new WeakMap();
 /**
  * 将账户表项转为 Base58（与 `PublicKey.toBase58()` 一致）。
  * 兼容：已是地址字符串、标准 `PublicKey`、以及多份 `@solana/web3.js` 副本导致 `instanceof` 失效的情况。
@@ -37,7 +38,13 @@ function accountKeyToBase58(account) {
     const maybeFn = account.toBase58;
     if (typeof maybeFn === "function") {
         try {
-            return maybeFn.call(account);
+            const object = account;
+            const cached = accountKeyBase58Cache.get(object);
+            if (cached !== undefined)
+                return cached;
+            const encoded = maybeFn.call(account);
+            accountKeyBase58Cache.set(object, encoded);
+            return encoded;
         }
         catch {
             /* fall through */

package/dist/grpc/async_event_queue.d.ts

@@ -13,6 +13,9 @@ export declare class AsyncEventQueue<T> implements AsyncIterable<T>, AsyncIterat
     push(item: T): boolean;
     len(): number;
     dropped(): number;
+    /** Synchronous O(1) dequeue for internal scheduled consumers. */
+    shift(): T | undefined;
+    clear(): void;
     close(): void;
     next(): Promise<IteratorResult<T>>;
     [Symbol.asyncIterator](): AsyncIterator<T>;

package/dist/grpc/async_event_queue.js

@@ -45,6 +45,20 @@ class AsyncEventQueue {
     dropped() {
         return this.droppedCount;
     }
+    /** Synchronous O(1) dequeue for internal scheduled consumers. */
+    shift() {
+        if (this.size === 0)
+            return undefined;
+        const item = this.items[this.head];
+        this.items[this.head] = undefined;
+        this.head = (this.head + 1) % this.maxSize;
+        this.size--;
+        return item;
+    }
+    clear() {
+        while (this.size > 0)
+            this.shift();
+    }
     close() {
         if (this.closed)
             return;
@@ -55,11 +69,7 @@ class AsyncEventQueue {
     }
     next() {
         if (this.size > 0) {
-            const item = this.items[this.head];
-            this.items[this.head] = undefined;
-            this.head = (this.head + 1) % this.maxSize;
-            this.size--;
-            return Promise.resolve({ value: item, done: false });
+            return Promise.resolve({ value: this.shift(), done: false });
         }
         if (this.closed) {
             return Promise.resolve({ value: undefined, done: true });

package/dist/grpc/client.d.ts

@@ -2,7 +2,7 @@
  * Yellowstone gRPC 客户端实现 - 基于 @triton-one/yellowstone-grpc
  */
 import { CommitmentLevel } from "@triton-one/yellowstone-grpc";
-import type { DexEvent } from "../core/dex_event.js";
+import { type DexEvent } from "../core/dex_event.js";
 import { type EventQueueOverflowStrategy } from "./async_event_queue.js";
 import { type AccountFilter, type ClientConfig, type EventTypeFilter, type TransactionFilter, type SubscribeCallbacks } from "./types.js";
 export { SubscribeCallbacks };
@@ -13,15 +13,33 @@ export interface DexEventSubscription extends AsyncIterable<DexEvent> {
     cancel(): void;
     next(): Promise<IteratorResult<DexEvent>>;
     len(): number;
+    /** Total drops across ingress and the public event queue. */
     dropped(): number;
+    eventDropped(): number;
+    ingressLen(): number;
+    ingressDropped(): number;
+    isStreamConnected(): boolean;
+    streamDisconnects(): number;
+    reconnects(): number;
+    replayedUpdates(): number;
+    /** Reconnects that could not resume from the last parsed slot. */
+    continuityBreaks(): number;
 }
 export interface SubscribeDexEventsOptions {
     autoReconnect?: boolean;
     /**
-     * Queue behavior when an async-iterator consumer cannot keep up. The default
-     * preserves the existing behavior; `drop-oldest` favors staying near chain tip.
+     * Queue behavior when parsing or the async-iterator consumer cannot keep up.
+     * The default preserves existing behavior; `drop-oldest` favors chain-tip latency.
      */
     queueOverflowStrategy?: EventQueueOverflowStrategy;
+    /** Raw Yellowstone updates retained before CPU-heavy parsing. Defaults to min(buffer_size, 1024). */
+    ingressBufferSize?: number;
+    /** Maximum raw updates parsed before yielding back to Node's event loop. Defaults to 8. */
+    parserBatchSize?: number;
+    /** Resume from the last parsed slot after reconnect. Defaults to true. */
+    replayOnReconnect?: boolean;
+    /** Parsed slots retained for replay deduplication. Defaults to 128. */
+    replayDedupeSlots?: number;
 }
 /** Yellowstone gRPC 客户端包装器 */
 export declare class YellowstoneGrpc {

package/dist/grpc/client.js

@@ -42,6 +42,8 @@ exports.YellowstoneGrpc = void 0;
  */
 const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
 const bs58_1 = __importDefault(require("bs58"));
+const node_buffer_1 = require("node:buffer");
+const dex_event_js_1 = require("../core/dex_event.js");
 const metadata_js_1 = require("../core/metadata.js");
 const mod_js_1 = require("../accounts/mod.js");
 const geyser_connect_js_1 = require("./geyser_connect.js");
@@ -58,6 +60,42 @@ function cancelSubscribeStream(stream) {
     stream.once("error", () => { });
     stream.cancel();
 }
+function positiveIntegerOption(value, fallback, name) {
+    const normalized = value ?? fallback;
+    if (!Number.isInteger(normalized) || normalized < 1) {
+        throw new RangeError(`${name} must be a positive integer`);
+    }
+    return normalized;
+}
+function replayUnsupported(error) {
+    const grpcError = error;
+    if (grpcError.code === 3 || grpcError.code === 11 || grpcError.code === 12)
+        return true;
+    return /from.?slot.*(?:unsupported|disabled|unavailable|invalid)/i.test(`${grpcError.message ?? ""} ${grpcError.details ?? ""}`);
+}
+function updateSlot(update) {
+    const value = update.transaction?.slot ?? update.account?.slot;
+    if (value === undefined || value === null)
+        return undefined;
+    try {
+        return BigInt(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function bytesKey(value) {
+    return node_buffer_1.Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
+}
+function updateIdentity(update) {
+    const transaction = update.transaction?.transaction;
+    if (transaction?.signature)
+        return `t:${bytesKey(transaction.signature)}`;
+    const account = update.account?.account;
+    if (!account?.pubkey)
+        return undefined;
+    return `a:${bytesKey(account.pubkey)}:${String(update.account?.slot ?? 0)}:${String(account.writeVersion ?? 0)}`;
+}
 /** Yellowstone gRPC 客户端包装器 */
 class YellowstoneGrpc {
     client;
@@ -430,18 +468,35 @@ class YellowstoneGrpc {
         await this.connect();
         const id = `dex_${Date.now()}_${Math.random().toString(36).slice(2)}`;
         const events = new async_event_queue_js_1.AsyncEventQueue(Math.max(1, this.config.buffer_size), options?.queueOverflowStrategy);
+        const ingressBufferSize = positiveIntegerOption(options?.ingressBufferSize, Math.min(this.config.buffer_size, 1024), "ingressBufferSize");
+        const parserBatchSize = positiveIntegerOption(options?.parserBatchSize, 8, "parserBatchSize");
+        const replayDedupeSlots = positiveIntegerOption(options?.replayDedupeSlots, 128, "replayDedupeSlots");
+        const replayOnReconnect = options?.replayOnReconnect !== false;
+        const ingress = new async_event_queue_js_1.AsyncEventQueue(ingressBufferSize, options?.queueOverflowStrategy);
         const errors = new async_event_queue_js_1.AsyncEventQueue(Math.max(1, this.config.buffer_size));
         const order = new order_buffer_js_1.OrderDispatcher(this.config);
-        let nextDropWarningAt = 0;
+        const eventDropped = events.dropped.bind(events);
+        let nextEventDropWarningAt = 0;
+        let nextIngressDropWarningAt = 0;
+        let streamConnected = false;
+        let streamDisconnectCount = 0;
+        let reconnectCount = 0;
+        let replayedUpdateCount = 0;
+        let continuityBreakCount = 0;
+        let lastParsedSlot;
+        let highestRememberedSlot = 0n;
+        let seenHead = 0;
+        const seenUpdates = new Map();
+        const seenOrder = [];
         const reportError = (error) => errors.push(error);
         const emitEvent = (event) => {
             if (events.push(event))
                 return;
             const now = Date.now();
-            if (now < nextDropWarningAt)
+            if (now < nextEventDropWarningAt)
                 return;
-            nextDropWarningAt = now + 10_000;
-            reportError(new Error(`Dex event queue full; dropped=${events.dropped()} buffer_size=${this.config.buffer_size} ` +
+            nextEventDropWarningAt = now + 10_000;
+            reportError(new Error(`Dex event queue full; dropped=${eventDropped()} buffer_size=${this.config.buffer_size} ` +
                 `strategy=${options?.queueOverflowStrategy ?? "drop-newest"}`));
         };
         let flushTimer;
@@ -452,6 +507,133 @@ class YellowstoneGrpc {
             flushTimer = setInterval(() => order.flushDue(emitEvent), intervalMs);
         }
         let isCancelled = false;
+        let ingressDrainScheduled = false;
+        let ingressDrainHandle;
+        const ingressIdleWaiters = [];
+        const resolveIngressIdle = () => {
+            if (ingress.len() > 0 || ingressDrainScheduled)
+                return;
+            for (const resolve of ingressIdleWaiters.splice(0))
+                resolve();
+        };
+        const annotateLocalMetrics = (events, grpcRecvNs, parseStartedNs, parseFinishedNs) => {
+            if (grpcRecvNs === undefined || parseStartedNs === undefined || parseFinishedNs === undefined) {
+                return;
+            }
+            const queueUs = Number(parseStartedNs - grpcRecvNs) / 1_000;
+            const parseUs = Number(parseFinishedNs - parseStartedNs) / 1_000;
+            const processingUs = Number(parseFinishedNs - grpcRecvNs) / 1_000;
+            for (const event of events) {
+                const metadata = (0, dex_event_js_1.metadataForDexEvent)(event);
+                if (!metadata)
+                    continue;
+                metadata.local_queue_latency_us = queueUs;
+                metadata.parse_duration_us = parseUs;
+                metadata.local_processing_latency_us = processingUs;
+            }
+        };
+        const rememberParsedUpdate = (identity, slot) => {
+            if (slot !== undefined && (lastParsedSlot === undefined || slot > lastParsedSlot)) {
+                lastParsedSlot = slot;
+            }
+            if (!replayOnReconnect || identity === undefined || slot === undefined)
+                return;
+            seenUpdates.set(identity, slot);
+            seenOrder.push({ identity, slot });
+            if (slot > highestRememberedSlot)
+                highestRememberedSlot = slot;
+            const retainFrom = highestRememberedSlot > BigInt(replayDedupeSlots)
+                ? highestRememberedSlot - BigInt(replayDedupeSlots)
+                : 0n;
+            while (seenHead < seenOrder.length && seenOrder[seenHead].slot < retainFrom) {
+                const stale = seenOrder[seenHead++];
+                if (seenUpdates.get(stale.identity) === stale.slot)
+                    seenUpdates.delete(stale.identity);
+            }
+            if (seenHead >= 4096 && seenHead * 2 >= seenOrder.length) {
+                seenOrder.splice(0, seenHead);
+                seenHead = 0;
+            }
+        };
+        const processUpdate = ({ update, grpcRecvUs, grpcRecvNs, blockTimeUs }) => {
+            const identity = updateIdentity(update);
+            const slotForReplay = updateSlot(update);
+            if (replayOnReconnect && identity !== undefined && seenUpdates.has(identity)) {
+                replayedUpdateCount++;
+                rememberParsedUpdate(undefined, slotForReplay);
+                return;
+            }
+            if (order.needsTimer)
+                order.flushDue(emitEvent);
+            const txUpdate = update.transaction;
+            const tx = txUpdate?.transaction;
+            if (tx) {
+                const parseStartedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
+                const slot = txUpdate?.slot ?? 0n;
+                const fallbackSlot = YellowstoneGrpc.protobufNumber(slot);
+                const fallbackTxIndex = YellowstoneGrpc.protobufNumber(tx.index ?? 0);
+                const txInfo = {
+                    signature: tx.signature,
+                    isVote: tx.isVote,
+                    transactionRaw: tx.transaction,
+                    metaRaw: tx.meta,
+                    index: (tx.index ?? 0n),
+                };
+                const txEvents = (0, yellowstone_parse_js_1.parseDexEventsFromGrpcTransactionInfo)(txInfo, slot, {
+                    blockTimeUs,
+                    grpcRecvUs,
+                    eventTypeFilter,
+                });
+                const parseFinishedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
+                annotateLocalMetrics(txEvents, grpcRecvNs, parseStartedNs, parseFinishedNs);
+                order.pushTransactionEvents(txEvents, fallbackSlot, fallbackTxIndex, emitEvent);
+            }
+            if (update.account) {
+                const parseStartedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
+                const ev = this.parseAccountEventRaw(update.account, grpcRecvUs, eventTypeFilter, blockTimeUs);
+                const parseFinishedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
+                if (ev)
+                    annotateLocalMetrics([ev], grpcRecvNs, parseStartedNs, parseFinishedNs);
+                if (ev)
+                    emitEvent(ev);
+            }
+            rememberParsedUpdate(identity, slotForReplay);
+        };
+        const scheduleIngressDrain = () => {
+            if (isCancelled || ingressDrainScheduled || ingress.len() === 0)
+                return;
+            ingressDrainScheduled = true;
+            ingressDrainHandle = setImmediate(() => {
+                ingressDrainHandle = undefined;
+                ingressDrainScheduled = false;
+                if (isCancelled) {
+                    resolveIngressIdle();
+                    return;
+                }
+                let processed = 0;
+                while (processed < parserBatchSize) {
+                    const pending = ingress.shift();
+                    if (!pending)
+                        break;
+                    try {
+                        processUpdate(pending);
+                    }
+                    catch (err) {
+                        reportError(err instanceof Error ? err : new Error(String(err)));
+                    }
+                    processed++;
+                }
+                if (ingress.len() > 0)
+                    scheduleIngressDrain();
+                else
+                    resolveIngressIdle();
+            });
+        };
+        const waitForIngressIdle = () => {
+            if (ingress.len() === 0 && !ingressDrainScheduled)
+                return Promise.resolve();
+            return new Promise((resolve) => ingressIdleWaiters.push(resolve));
+        };
         let currentTransactionFilters = transactionFilters;
         let currentAccountFilters = accountFilters;
         const streamHolder = { current: null };
@@ -477,6 +659,13 @@ class YellowstoneGrpc {
             cancelReconnectDelay?.();
             cancelSubscribeStream(streamHolder.current);
             streamHolder.current = null;
+            if (ingressDrainHandle)
+                clearImmediate(ingressDrainHandle);
+            ingressDrainHandle = undefined;
+            ingressDrainScheduled = false;
+            ingress.clear();
+            ingress.close();
+            resolveIngressIdle();
             if (flushTimer)
                 clearInterval(flushTimer);
             events.close();
@@ -502,25 +691,39 @@ class YellowstoneGrpc {
             const autoReconnect = options?.autoReconnect !== false;
             const maxBackoffMs = 60_000;
             let backoffMs = this.config.retry_delay_ms;
+            let replayAllowed = replayOnReconnect;
+            let attempt = 0;
             try {
                 while (!isCancelled) {
+                    let attemptedReplay = false;
+                    let receivedData = false;
                     try {
+                        attempt++;
+                        if (attempt > 1)
+                            reconnectCount++;
                         const stream = await this.client.subscribe();
                         if (isCancelled) {
                             cancelSubscribeStream(stream);
                             break;
                         }
                         streamHolder.current = stream;
+                        const request = (0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters);
+                        if (attempt > 1 && replayAllowed && lastParsedSlot !== undefined) {
+                            request.fromSlot = lastParsedSlot.toString();
+                            attemptedReplay = true;
+                        }
                         await new Promise((resolve, reject) => {
-                            stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
+                            stream.write(request, (err) => {
                                 if (err)
                                     reject(err);
                                 else
                                     resolve();
                             });
                         });
+                        streamConnected = true;
                         await new Promise((resolve, reject) => {
                             const cleanup = () => {
+                                streamConnected = false;
                                 stream.removeAllListeners();
                                 if (streamHolder.current === stream) {
                                     streamHolder.current = null;
@@ -529,9 +732,12 @@ class YellowstoneGrpc {
                             stream.on("data", (update) => {
                                 if (isCancelled)
                                     return;
+                                receivedData = true;
+                                const grpcRecvNs = this.config.enable_metrics
+                                    ? process.hrtime.bigint()
+                                    : undefined;
+                                const grpcRecvUs = Math.floor(Date.now() * 1000);
                                 backoffMs = this.config.retry_delay_ms;
-                                if (order.needsTimer)
-                                    order.flushDue(emitEvent);
                                 if (update.ping) {
                                     stream.write(this.subscribePingPongRequest(), (werr) => {
                                         if (werr && !isCancelled) {
@@ -540,41 +746,33 @@ class YellowstoneGrpc {
                                     });
                                     return;
                                 }
-                                try {
-                                    const grpcRecvUs = Math.floor(Date.now() * 1000);
-                                    const blockTimeUs = YellowstoneGrpc.timestampToMicros(update.createdAt ?? update.created_at);
-                                    const txUpdate = update.transaction;
-                                    const tx = txUpdate?.transaction;
-                                    if (tx) {
-                                        const slot = txUpdate?.slot ?? 0n;
-                                        const fallbackSlot = YellowstoneGrpc.protobufNumber(slot);
-                                        const fallbackTxIndex = YellowstoneGrpc.protobufNumber(tx.index ?? 0);
-                                        const txInfo = {
-                                            signature: tx.signature,
-                                            isVote: tx.isVote,
-                                            transactionRaw: tx.transaction,
-                                            metaRaw: tx.meta,
-                                            index: (tx.index ?? 0n),
-                                        };
-                                        const txEvents = (0, yellowstone_parse_js_1.parseDexEventsFromGrpcTransactionInfo)(txInfo, slot, { blockTimeUs, grpcRecvUs, eventTypeFilter });
-                                        order.pushTransactionEvents(txEvents, fallbackSlot, fallbackTxIndex, emitEvent);
-                                    }
-                                    if (update.account) {
-                                        const ev = this.parseAccountEventRaw(update.account, grpcRecvUs, eventTypeFilter, blockTimeUs);
-                                        if (ev)
-                                            emitEvent(ev);
+                                const accepted = ingress.push({
+                                    update,
+                                    grpcRecvUs,
+                                    grpcRecvNs,
+                                    blockTimeUs: YellowstoneGrpc.timestampToMicros(update.createdAt ?? update.created_at),
+                                });
+                                if (!accepted) {
+                                    const now = Date.now();
+                                    if (now >= nextIngressDropWarningAt) {
+                                        nextIngressDropWarningAt = now + 10_000;
+                                        reportError(new Error(`Yellowstone ingress queue full; dropped=${ingress.dropped()} ` +
+                                            `buffer_size=${ingressBufferSize} ` +
+                                            `strategy=${options?.queueOverflowStrategy ?? "drop-newest"}`));
                                     }
                                 }
-                                catch (err) {
-                                    reportError(err instanceof Error ? err : new Error(String(err)));
-                                }
+                                scheduleIngressDrain();
                             });
                             stream.on("error", (err) => {
+                                streamDisconnectCount++;
                                 cleanup();
                                 reject(err);
                             });
                             stream.on("end", () => {
+                                streamDisconnectCount++;
                                 cleanup();
+                                if (!isCancelled)
+                                    reportError(new Error("Yellowstone stream ended; reconnecting"));
                                 resolve();
                             });
                         });
@@ -584,15 +782,38 @@ class YellowstoneGrpc {
                             break;
                         cancelSubscribeStream(streamHolder.current);
                         streamHolder.current = null;
+                        streamConnected = false;
                         reportError(err instanceof Error ? err : new Error(String(err)));
-                        if (!autoReconnect)
+                        await waitForIngressIdle();
+                        if (!autoReconnect) {
+                            if (lastParsedSlot !== undefined)
+                                continuityBreakCount++;
                             break;
+                        }
+                        let continuityBreakRecorded = false;
+                        if (attemptedReplay && !receivedData && replayUnsupported(err)) {
+                            replayAllowed = false;
+                            continuityBreakCount++;
+                            continuityBreakRecorded = true;
+                            reportError(new Error("Yellowstone provider rejected fromSlot replay; reconnecting live and continuity is not guaranteed"));
+                        }
+                        if (!replayAllowed && lastParsedSlot !== undefined && !continuityBreakRecorded) {
+                            continuityBreakCount++;
+                        }
                         await waitBeforeReconnect(backoffMs);
                         backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
                         continue;
                     }
-                    if (isCancelled || !autoReconnect)
+                    await waitForIngressIdle();
+                    if (isCancelled)
+                        break;
+                    if (!autoReconnect) {
+                        if (lastParsedSlot !== undefined)
+                            continuityBreakCount++;
                         break;
+                    }
+                    if (!replayAllowed && lastParsedSlot !== undefined)
+                        continuityBreakCount++;
                     await waitBeforeReconnect(backoffMs);
                     backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
                 }
@@ -600,10 +821,14 @@ class YellowstoneGrpc {
             finally {
                 cancelSubscribeStream(streamHolder.current);
                 streamHolder.current = null;
+                streamConnected = false;
                 if (flushTimer)
                     clearInterval(flushTimer);
-                if (!isCancelled)
+                if (!isCancelled) {
+                    await waitForIngressIdle();
                     order.flushAll(emitEvent);
+                }
+                ingress.close();
                 events.close();
                 errors.close();
                 this.dexSubscribers.delete(id);
@@ -612,6 +837,15 @@ class YellowstoneGrpc {
         return Object.assign(events, {
             id,
             errors,
+            dropped: () => eventDropped() + ingress.dropped(),
+            eventDropped,
+            ingressLen: () => ingress.len(),
+            ingressDropped: () => ingress.dropped(),
+            isStreamConnected: () => streamConnected,
+            streamDisconnects: () => streamDisconnectCount,
+            reconnects: () => reconnectCount,
+            replayedUpdates: () => replayedUpdateCount,
+            continuityBreaks: () => continuityBreakCount,
             cancel: () => {
                 cancel();
                 this.dexSubscribers.delete(id);

package/dist/grpc/program_ids.d.ts

@@ -23,5 +23,13 @@ export declare const PROTOCOL_PROGRAM_IDS: Record<Protocol, readonly string[]>;
 export declare function getProgramIdsForProtocols(protocols: readonly Protocol[]): string[];
 /** 与 Rust `TransactionFilter::for_protocols` 一致 */
 export declare function transactionFilterForProtocols(protocols: readonly Protocol[]): TransactionFilter;
+/**
+ * Server-side transaction filter for one protocol restricted to known accounts.
+ *
+ * Yellowstone applies `account_include` as ANY and `account_required` as ALL,
+ * so matching transactions must contain the protocol program and at least one
+ * tracked mint, pool, or other account.
+ */
+export declare function transactionFilterForProtocolAccounts(protocol: Protocol, accounts: readonly string[]): TransactionFilter;
 /** 与 Rust `AccountFilter::for_protocols` 一致 */
 export declare function accountFilterForProtocols(protocols: readonly Protocol[]): AccountFilter;

package/dist/grpc/program_ids.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROTOCOL_PROGRAM_IDS = exports.METEORA_DBC_PROGRAM_ID = exports.METEORA_DLMM_PROGRAM_ID = exports.METEORA_DAMM_V2_PROGRAM_ID = exports.METEORA_POOLS_PROGRAM_ID = exports.ORCA_WHIRLPOOL_PROGRAM_ID = exports.RAYDIUM_AMM_V4_PROGRAM_ID = exports.RAYDIUM_CLMM_PROGRAM_ID = exports.RAYDIUM_CPMM_PROGRAM_ID = exports.RAYDIUM_LAUNCHLAB_PROGRAM_ID = exports.PUMP_FEES_PROGRAM_ID = exports.PUMPSWAP_FEES_PROGRAM_ID = exports.PUMPSWAP_PROGRAM_ID = exports.PUMPFUN_PROGRAM_ID = void 0;
 exports.getProgramIdsForProtocols = getProgramIdsForProtocols;
 exports.transactionFilterForProtocols = transactionFilterForProtocols;
+exports.transactionFilterForProtocolAccounts = transactionFilterForProtocolAccounts;
 exports.accountFilterForProtocols = accountFilterForProtocols;
 exports.PUMPFUN_PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
 exports.PUMPSWAP_PROGRAM_ID = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
@@ -51,6 +52,26 @@ function transactionFilterForProtocols(protocols) {
         account_required: [],
     };
 }
+/**
+ * Server-side transaction filter for one protocol restricted to known accounts.
+ *
+ * Yellowstone applies `account_include` as ANY and `account_required` as ALL,
+ * so matching transactions must contain the protocol program and at least one
+ * tracked mint, pool, or other account.
+ */
+function transactionFilterForProtocolAccounts(protocol, accounts) {
+    const trackedAccounts = [
+        ...new Set(accounts.map((account) => account.trim()).filter((account) => account.length > 0)),
+    ].sort();
+    if (trackedAccounts.length === 0) {
+        throw new RangeError("At least one tracked account is required");
+    }
+    return {
+        account_include: trackedAccounts,
+        account_exclude: [],
+        account_required: [...exports.PROTOCOL_PROGRAM_IDS[protocol]],
+    };
+}
 /** 与 Rust `AccountFilter::for_protocols` 一致 */
 function accountFilterForProtocols(protocols) {
     return {

package/dist/grpc/yellowstone_parse.js

@@ -5,15 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.grpcTxIndexFromInfo = grpcTxIndexFromInfo;
 exports.parseDexEventsFromGrpcTransactionInfo = parseDexEventsFromGrpcTransactionInfo;
-/**
- * Yellowstone gRPC 单笔交易：统一交易解析（指令 + 日志 + 与 Rust 相同的账户/数据填充）。
- * 依赖 `@triton-one/yellowstone-grpc` 的 `txEncode`（Binary）得到与 web3 兼容的 meta + 反序列化交易。
- */
-const yellowstone_grpc_1 = require("@triton-one/yellowstone-grpc");
-const yellowstone_grpc_solana_encoding_wasm_js_1 = require("@triton-one/yellowstone-grpc/dist/encoding/yellowstone_grpc_solana_encoding_wasm.js");
 const bs58_1 = __importDefault(require("bs58"));
-const web3_js_1 = require("@solana/web3.js");
 const rpc_transaction_js_1 = require("../rpc_transaction.js");
+const yellowstone_transaction_adapter_js_1 = require("./yellowstone_transaction_adapter.js");
 /**
  * Yellowstone `SubscribeUpdateTransactionInfo.index` → `EventMetadata.tx_index`。
  * 与 Rust `sol-parser-sdk` gRPC 路径中 `let idx = info.index` 传入 `parse_logs(..., idx, ...)` 一致。
@@ -41,19 +35,14 @@ function parseDexEventsFromGrpcTransactionInfo(info, slot, options) {
         meta: mr,
         index: String(info.index),
     };
-    const enc = yellowstone_grpc_1.txEncode.encode(y, yellowstone_grpc_solana_encoding_wasm_js_1.WasmUiTransactionEncoding.Binary, 0, false);
-    const vt = web3_js_1.VersionedTransaction.deserialize(bs58_1.default.decode(enc.transaction));
-    const meta = enc.meta;
     const slotNum = typeof slot === "bigint" ? Number(slot) : Number(slot);
     const signatureBase58 = bs58_1.default.encode(Uint8Array.from(info.signature));
     const txIndex = grpcTxIndexFromInfo(info);
     const blockTime = options?.blockTimeUs == null ? null : Math.floor(options.blockTimeUs / 1_000_000);
-    const parsed = (0, rpc_transaction_js_1.parseRpcTransaction)({
-        slot: slotNum,
-        blockTime,
-        meta,
-        transaction: vt,
-    }, signatureBase58, options?.eventTypeFilter, {
+    const response = (0, yellowstone_transaction_adapter_js_1.yellowstoneTransactionToWeb3)(y.transaction, y.meta, slotNum, blockTime);
+    // This reuses the parser for the web3-compatible in-memory shape. It does not
+    // perform an RPC request or any other network I/O.
+    const parsed = (0, rpc_transaction_js_1.parseRpcTransaction)(response, signatureBase58, options?.eventTypeFilter, {
         blockTimeUs: options?.blockTimeUs,
         grpcRecvUs: options?.grpcRecvUs,
         txIndex,

package/dist/grpc/yellowstone_transaction_adapter.d.ts

@@ -0,0 +1,4 @@
+import { type VersionedTransactionResponse } from "@solana/web3.js";
+import type { Transaction as YellowstoneTransaction, TransactionStatusMeta as YellowstoneMeta } from "@triton-one/yellowstone-grpc/dist/grpc/solana-storage.js";
+/** Convert Yellowstone protobuf objects directly, without a WASM/Base58 serialization round trip. */
+export declare function yellowstoneTransactionToWeb3(transaction: YellowstoneTransaction, meta: YellowstoneMeta, slot: number, blockTime: number | null): VersionedTransactionResponse;

package/dist/grpc/yellowstone_transaction_adapter.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yellowstoneTransactionToWeb3 = yellowstoneTransactionToWeb3;
+const bs58_1 = __importDefault(require("bs58"));
+const web3_js_1 = require("@solana/web3.js");
+function publicKey(bytes) {
+    return new web3_js_1.PublicKey(bytes);
+}
+function messageHeader(message) {
+    const header = message.header;
+    if (!header)
+        throw new TypeError("Yellowstone transaction message is missing its header");
+    return {
+        numRequiredSignatures: header.numRequiredSignatures,
+        numReadonlySignedAccounts: header.numReadonlySignedAccounts,
+        numReadonlyUnsignedAccounts: header.numReadonlyUnsignedAccounts,
+    };
+}
+function legacyMessage(message) {
+    const instructions = message.instructions.map((instruction) => ({
+        programIdIndex: instruction.programIdIndex,
+        accounts: [...instruction.accounts],
+        data: bs58_1.default.encode(instruction.data),
+    }));
+    return new web3_js_1.Message({
+        header: messageHeader(message),
+        accountKeys: message.accountKeys.map(publicKey),
+        recentBlockhash: bs58_1.default.encode(message.recentBlockhash),
+        instructions,
+    });
+}
+function versionedMessage(message) {
+    const compiledInstructions = message.instructions.map((instruction) => ({
+        programIdIndex: instruction.programIdIndex,
+        accountKeyIndexes: [...instruction.accounts],
+        data: instruction.data,
+    }));
+    return new web3_js_1.MessageV0({
+        header: messageHeader(message),
+        staticAccountKeys: message.accountKeys.map(publicKey),
+        recentBlockhash: bs58_1.default.encode(message.recentBlockhash),
+        compiledInstructions,
+        addressTableLookups: message.addressTableLookups.map((lookup) => ({
+            accountKey: publicKey(lookup.accountKey),
+            writableIndexes: [...lookup.writableIndexes],
+            readonlyIndexes: [...lookup.readonlyIndexes],
+        })),
+    });
+}
+function transactionMeta(meta) {
+    return {
+        err: null,
+        fee: Number(meta.fee),
+        preBalances: meta.preBalances.map(Number),
+        postBalances: meta.postBalances.map(Number),
+        innerInstructions: meta.innerInstructionsNone
+            ? null
+            : meta.innerInstructions.map((group) => ({
+                index: group.index,
+                instructions: group.instructions.map((instruction) => ({
+                    programIdIndex: instruction.programIdIndex,
+                    accounts: [...instruction.accounts],
+                    // The internal parser accepts bytes directly; keep Yellowstone's representation
+                    // instead of paying for a Base58 encode followed by an immediate decode.
+                    data: instruction.data,
+                    ...(instruction.stackHeight !== undefined
+                        ? { stackHeight: instruction.stackHeight }
+                        : {}),
+                })),
+            })),
+        logMessages: meta.logMessagesNone ? null : meta.logMessages,
+        preTokenBalances: [],
+        postTokenBalances: [],
+        loadedAddresses: {
+            writable: meta.loadedWritableAddresses.map(publicKey),
+            readonly: meta.loadedReadonlyAddresses.map(publicKey),
+        },
+        ...(meta.computeUnitsConsumed !== undefined
+            ? { computeUnitsConsumed: Number(meta.computeUnitsConsumed) }
+            : {}),
+    };
+}
+/** Convert Yellowstone protobuf objects directly, without a WASM/Base58 serialization round trip. */
+function yellowstoneTransactionToWeb3(transaction, meta, slot, blockTime) {
+    const message = transaction.message;
+    if (!message)
+        throw new TypeError("Yellowstone transaction is missing its message");
+    return {
+        slot,
+        blockTime,
+        meta: transactionMeta(meta),
+        transaction: {
+            message: message.versioned ? versionedMessage(message) : legacyMessage(message),
+            signatures: transaction.signatures.map((signature) => bs58_1.default.encode(signature)),
+        },
+        version: message.versioned ? 0 : "legacy",
+    };
+}

package/dist/index.d.ts

@@ -19,8 +19,8 @@ export { pubkeyBytesToBs58 as pubkey_bytes_to_bs58, collectAccountKeysBs58 as co
 export { type OrderMode, type Protocol, type ClientConfig, type StreamingConfig, type TransactionFilter, type AccountFilter, type AccountFilterData, type AccountFilterMemcmp, type SlotFilter, type EventType, type StreamingEventType, type EventTypeFilter, defaultClientConfig, lowLatencyClientConfig, highThroughputClientConfig, newTransactionFilter, transactionFilterFromProgramIds, newAccountFilter, newSlotFilter, slotFilterMinSlot, slotFilterMaxSlot, accountFilterFromProgramOwners, accountFilterMemcmp, eventTypeFilterIncludeOnly, eventTypeFilterExclude, eventTypeFilterIncludesPumpfun, eventTypeFilterIncludesPumpswap, eventTypeFilterIncludesMeteoraDammV2, eventTypeFilterIncludesMeteoraDbc, eventTypeFilterIncludesMeteoraPools, eventTypeFilterIncludesMeteoraDlmm, eventTypeFilterIncludesRaydiumClmm, eventTypeFilterIncludesRaydiumCpmm, eventTypeFilterIncludesRaydiumAmmV4, eventTypeFilterIncludesOrcaWhirlpool, eventTypeFilterIncludesRaydiumLaunchlab, eventTypeFilterIncludesPumpFees, eventTypeFilterAllowsInstructionParsing, ALL_EVENT_TYPES, } from "./grpc/types.js";
 export { ALL_EVENT_TYPES as all_event_types } from "./grpc/types.js";
 export type { StreamingConfig as streaming_config } from "./grpc/types.js";
-export { PROTOCOL_PROGRAM_IDS, PUMPFUN_PROGRAM_ID, PUMPSWAP_PROGRAM_ID, PUMPSWAP_FEES_PROGRAM_ID, PUMP_FEES_PROGRAM_ID, RAYDIUM_LAUNCHLAB_PROGRAM_ID, RAYDIUM_CPMM_PROGRAM_ID, RAYDIUM_CLMM_PROGRAM_ID, RAYDIUM_AMM_V4_PROGRAM_ID, ORCA_WHIRLPOOL_PROGRAM_ID, METEORA_POOLS_PROGRAM_ID, METEORA_DAMM_V2_PROGRAM_ID, METEORA_DLMM_PROGRAM_ID, METEORA_DBC_PROGRAM_ID, getProgramIdsForProtocols, transactionFilterForProtocols, accountFilterForProtocols, } from "./grpc/program_ids.js";
-export { PROTOCOL_PROGRAM_IDS as protocol_program_ids, getProgramIdsForProtocols as get_program_ids_for_protocols, transactionFilterForProtocols as transaction_filter_for_protocols, accountFilterForProtocols as account_filter_for_protocols, } from "./grpc/program_ids.js";
+export { PROTOCOL_PROGRAM_IDS, PUMPFUN_PROGRAM_ID, PUMPSWAP_PROGRAM_ID, PUMPSWAP_FEES_PROGRAM_ID, PUMP_FEES_PROGRAM_ID, RAYDIUM_LAUNCHLAB_PROGRAM_ID, RAYDIUM_CPMM_PROGRAM_ID, RAYDIUM_CLMM_PROGRAM_ID, RAYDIUM_AMM_V4_PROGRAM_ID, ORCA_WHIRLPOOL_PROGRAM_ID, METEORA_POOLS_PROGRAM_ID, METEORA_DAMM_V2_PROGRAM_ID, METEORA_DLMM_PROGRAM_ID, METEORA_DBC_PROGRAM_ID, getProgramIdsForProtocols, transactionFilterForProtocols, transactionFilterForProtocolAccounts, accountFilterForProtocols, } from "./grpc/program_ids.js";
+export { PROTOCOL_PROGRAM_IDS as protocol_program_ids, getProgramIdsForProtocols as get_program_ids_for_protocols, transactionFilterForProtocols as transaction_filter_for_protocols, transactionFilterForProtocolAccounts as transaction_filter_for_protocol_accounts, accountFilterForProtocols as account_filter_for_protocols, } from "./grpc/program_ids.js";
 /** Rust `grpc::types` 蛇形命名别名 */
 export { defaultClientConfig as default_client_config, lowLatencyClientConfig as low_latency_client_config, highThroughputClientConfig as high_throughput_client_config, newTransactionFilter as new_transaction_filter, transactionFilterFromProgramIds as transaction_filter_from_program_ids, newAccountFilter as new_account_filter, newSlotFilter as new_slot_filter, slotFilterMinSlot as slot_filter_min_slot, slotFilterMaxSlot as slot_filter_max_slot, accountFilterFromProgramOwners as account_filter_from_program_owners, accountFilterMemcmp as account_filter_memcmp, eventTypeFilterIncludeOnly as event_type_filter_include_only, eventTypeFilterExclude as event_type_filter_exclude, eventTypeFilterIncludeOnly as include_only, eventTypeFilterExclude as exclude_types, } from "./grpc/types.js";
 export { buildSubscribeRequest, buildSubscribeRequestWithCommitment, buildSubscribeTransactionFiltersNamed, CommitmentLevel, } from "./grpc/subscribe_builder.js";

package/dist/index.js

@@ -35,9 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.heuristicSolCounterpartiesForWatchedKeys = exports.lamportBalanceDeltas = exports.collectAccountKeysBs58 = exports.pubkeyBytesToBs58 = exports.grpcTxIndexFromInfo = exports.parseDexEventsFromGrpcTransactionInfo = exports.convert_rpc_to_grpc = exports.convertRpcToGrpc = exports.applyAccountFillsToLogEvents = exports.fillDataRpc = exports.fillAccountsFromTransactionDataRpc = exports.parseRpcTransaction = exports.parseTransactionFromRpc = exports.isWarmedUp = exports.warmupParser = exports.build_account_pubkeys_with_cache = exports.buildAccountPubkeysWithCache = exports.AccountPubkeyCache = exports.normalizeBuySellFromInputMint = exports.normalizeBuySellFromTokenDelta = exports.vaultPriceFromBalances = exports.sqrtPriceX64ToPrice = exports.elapsedMicrosSince = exports.nowNanos = exports.nowMicros = exports.nowUs = exports.parse_log = exports.parseLog = exports.parseTransactionWithStreamingListener = exports.parseLogsStreaming = exports.parseTransactionEventsStreaming = exports.parseTransactionWithListener = exports.parseLogsOnly = exports.parseTransactionEvents = exports.enrichPumpfunSameTxPostMerge = exports.enrichPumpfunTradesFromCreateInstructions = exports.enrichCreateV2ObservedFeeRecipient = exports.enrichCreateV2FromCreateEvents = exports.formatParseError = exports.dexEventToJsonString = exports.bigintToJsonReplacer = exports.defaultPubkey = exports.metadataForDexEvent = exports.SLOW_PROCESSING_THRESHOLD_US = exports.DEFAULT_REQUEST_TIMEOUT = exports.DEFAULT_METRICS_WINDOW_SECONDS = exports.DEFAULT_METRICS_PRINT_INTERVAL_SECONDS = exports.DEFAULT_MAX_DECODING_MESSAGE_SIZE = exports.DEFAULT_CONNECT_TIMEOUT = exports.DEFAULT_CHANNEL_SIZE = void 0;
 exports.ORCA_WHIRLPOOL_PROGRAM_ID = exports.RAYDIUM_AMM_V4_PROGRAM_ID = exports.RAYDIUM_CLMM_PROGRAM_ID = exports.RAYDIUM_CPMM_PROGRAM_ID = exports.RAYDIUM_LAUNCHLAB_PROGRAM_ID = exports.PUMP_FEES_PROGRAM_ID = exports.PUMPSWAP_FEES_PROGRAM_ID = exports.PUMPSWAP_PROGRAM_ID = exports.PUMPFUN_PROGRAM_ID = exports.PROTOCOL_PROGRAM_IDS = exports.all_event_types = exports.ALL_EVENT_TYPES = exports.eventTypeFilterAllowsInstructionParsing = exports.eventTypeFilterIncludesPumpFees = exports.eventTypeFilterIncludesRaydiumLaunchlab = exports.eventTypeFilterIncludesOrcaWhirlpool = exports.eventTypeFilterIncludesRaydiumAmmV4 = exports.eventTypeFilterIncludesRaydiumCpmm = exports.eventTypeFilterIncludesRaydiumClmm = exports.eventTypeFilterIncludesMeteoraDlmm = exports.eventTypeFilterIncludesMeteoraPools = exports.eventTypeFilterIncludesMeteoraDbc = exports.eventTypeFilterIncludesMeteoraDammV2 = exports.eventTypeFilterIncludesPumpswap = exports.eventTypeFilterIncludesPumpfun = exports.eventTypeFilterExclude = exports.eventTypeFilterIncludeOnly = exports.accountFilterMemcmp = exports.accountFilterFromProgramOwners = exports.slotFilterMaxSlot = exports.slotFilterMinSlot = exports.newSlotFilter = exports.newAccountFilter = exports.transactionFilterFromProgramIds = exports.newTransactionFilter = exports.highThroughputClientConfig = exports.lowLatencyClientConfig = exports.defaultClientConfig = exports.try_yellowstone_signature = exports.collect_watch_transfer_counterparty_pairs = exports.spl_token_counterparty_by_owner = exports.token_balance_raw_amount = exports.heuristic_sol_counterparties_for_watched_keys = exports.lamport_balance_deltas = exports.collect_account_keys_bs58 = exports.pubkey_bytes_to_bs58 = exports.tryYellowstoneSignature = exports.collectWatchTransferCounterpartyPairs = exports.splTokenCounterpartyByOwner = exports.tokenBalanceRawAmount = void 0;
-exports.PROGRAM_LOG_DISC = exports.parseMeteoraDammLog = exports.lookup_discriminator = exports.lookupDiscriminator = exports.discriminator_to_protocol = exports.discriminatorToProtocol = exports.discriminator_to_name = exports.discriminatorToName = exports.parse_log_unified = exports.parse_log_optimized = exports.parse_meteora_dlmm_log = exports.parse_meteora_damm_log = exports.parseProgramCompleteInfo = exports.parseLogUnified = exports.parseLogOptimizedWithProgramId = exports.parseLogOptimized = exports.parseInvokeInfo = exports.build_subscribe_transaction_filters_named = exports.build_subscribe_request_with_commitment = exports.build_subscribe_request = exports.CommitmentLevel = exports.buildSubscribeTransactionFiltersNamed = exports.buildSubscribeRequestWithCommitment = exports.buildSubscribeRequest = exports.exclude_types = exports.include_only = exports.event_type_filter_exclude = exports.event_type_filter_include_only = exports.account_filter_memcmp = exports.account_filter_from_program_owners = exports.slot_filter_max_slot = exports.slot_filter_min_slot = exports.new_slot_filter = exports.new_account_filter = exports.transaction_filter_from_program_ids = exports.new_transaction_filter = exports.high_throughput_client_config = exports.low_latency_client_config = exports.default_client_config = exports.account_filter_for_protocols = exports.transaction_filter_for_protocols = exports.get_program_ids_for_protocols = exports.protocol_program_ids = exports.accountFilterForProtocols = exports.transactionFilterForProtocols = exports.getProgramIdsForProtocols = exports.METEORA_DBC_PROGRAM_ID = exports.METEORA_DLMM_PROGRAM_ID = exports.METEORA_DAMM_V2_PROGRAM_ID = exports.METEORA_POOLS_PROGRAM_ID = void 0;
-exports.ShredEventQueue = exports.ShredStreamClient = exports.geyser_grpc_channel_options = exports.default_geyser_connect_config = exports.connect_yellowstone_geyser = exports.event_parser = exports.geyserGrpcChannelOptions = exports.defaultGeyserConnectConfig = exports.connectYellowstoneGeyser = exports.YellowstoneGrpc = exports.programIds = exports.parse_pump_fees_instruction = exports.parse_meteora_pools_instruction = exports.parse_meteora_dlmm_instruction = exports.parse_meteora_damm_instruction = exports.parse_pumpswap_instruction = exports.parse_pumpfun_instruction = exports.parse_instruction_unified = exports.parsePumpFeesInstruction = exports.parseMeteoraPoolsInstruction = exports.parseMeteoraDlmmInstruction = exports.parseMeteoraDammInstruction = exports.parsePumpswapInstruction = exports.parsePumpfunInstruction = exports.parseInstructionUnified = exports.user_wallet_pubkey_for_onchain_account = exports.rpc_resolve_user_wallet_pubkey = exports.parse_pumpswap_pool = exports.parse_pumpswap_global_config = exports.parse_pumpfun_global = exports.parse_token_account = exports.parse_nonce_account = exports.parse_account_unified = exports.rpcResolveUserWalletPubkey = exports.userWalletPubkeyForOnchainAccount = exports.hasDiscriminator = exports.isPoolAccount = exports.isGlobalConfigAccount = exports.parsePumpswapAccount = exports.parsePumpswapPool = exports.parsePumpswapGlobalConfig = exports.isPumpfunGlobalAccount = exports.parsePumpfunAccount = exports.parsePumpfunGlobal = exports.parseTokenAccount = exports.isNonceAccount = exports.parseNonceAccount = exports.parseAccountUnified = exports.u64leDiscriminator = exports.PUMPSWAP_DISC = void 0;
-exports.high_throughput_shred_stream_config = exports.low_latency_shred_stream_config = exports.default_shred_stream_config = exports.highThroughputShredStreamConfig = exports.lowLatencyShredStreamConfig = exports.defaultShredStreamConfig = exports.wireBytesToShredWasmTx = exports.decodeShredstreamEntriesBincode = exports.decodeEntriesBincodeNested = exports.decodeEntriesBincodeFlat = exports.bincodeVecEntryCount = exports.loadAddressLookupTableAccounts = exports.fullAccountKeyStringsFromShredTx = exports.dexEventsFromShredWasmTxWithFullKeys = exports.dexEventsFromShredWasmTx = void 0;
+exports.lookup_discriminator = exports.lookupDiscriminator = exports.discriminator_to_protocol = exports.discriminatorToProtocol = exports.discriminator_to_name = exports.discriminatorToName = exports.parse_log_unified = exports.parse_log_optimized = exports.parse_meteora_dlmm_log = exports.parse_meteora_damm_log = exports.parseProgramCompleteInfo = exports.parseLogUnified = exports.parseLogOptimizedWithProgramId = exports.parseLogOptimized = exports.parseInvokeInfo = exports.build_subscribe_transaction_filters_named = exports.build_subscribe_request_with_commitment = exports.build_subscribe_request = exports.CommitmentLevel = exports.buildSubscribeTransactionFiltersNamed = exports.buildSubscribeRequestWithCommitment = exports.buildSubscribeRequest = exports.exclude_types = exports.include_only = exports.event_type_filter_exclude = exports.event_type_filter_include_only = exports.account_filter_memcmp = exports.account_filter_from_program_owners = exports.slot_filter_max_slot = exports.slot_filter_min_slot = exports.new_slot_filter = exports.new_account_filter = exports.transaction_filter_from_program_ids = exports.new_transaction_filter = exports.high_throughput_client_config = exports.low_latency_client_config = exports.default_client_config = exports.account_filter_for_protocols = exports.transaction_filter_for_protocol_accounts = exports.transaction_filter_for_protocols = exports.get_program_ids_for_protocols = exports.protocol_program_ids = exports.accountFilterForProtocols = exports.transactionFilterForProtocolAccounts = exports.transactionFilterForProtocols = exports.getProgramIdsForProtocols = exports.METEORA_DBC_PROGRAM_ID = exports.METEORA_DLMM_PROGRAM_ID = exports.METEORA_DAMM_V2_PROGRAM_ID = exports.METEORA_POOLS_PROGRAM_ID = void 0;
+exports.geyser_grpc_channel_options = exports.default_geyser_connect_config = exports.connect_yellowstone_geyser = exports.event_parser = exports.geyserGrpcChannelOptions = exports.defaultGeyserConnectConfig = exports.connectYellowstoneGeyser = exports.YellowstoneGrpc = exports.programIds = exports.parse_pump_fees_instruction = exports.parse_meteora_pools_instruction = exports.parse_meteora_dlmm_instruction = exports.parse_meteora_damm_instruction = exports.parse_pumpswap_instruction = exports.parse_pumpfun_instruction = exports.parse_instruction_unified = exports.parsePumpFeesInstruction = exports.parseMeteoraPoolsInstruction = exports.parseMeteoraDlmmInstruction = exports.parseMeteoraDammInstruction = exports.parsePumpswapInstruction = exports.parsePumpfunInstruction = exports.parseInstructionUnified = exports.user_wallet_pubkey_for_onchain_account = exports.rpc_resolve_user_wallet_pubkey = exports.parse_pumpswap_pool = exports.parse_pumpswap_global_config = exports.parse_pumpfun_global = exports.parse_token_account = exports.parse_nonce_account = exports.parse_account_unified = exports.rpcResolveUserWalletPubkey = exports.userWalletPubkeyForOnchainAccount = exports.hasDiscriminator = exports.isPoolAccount = exports.isGlobalConfigAccount = exports.parsePumpswapAccount = exports.parsePumpswapPool = exports.parsePumpswapGlobalConfig = exports.isPumpfunGlobalAccount = exports.parsePumpfunAccount = exports.parsePumpfunGlobal = exports.parseTokenAccount = exports.isNonceAccount = exports.parseNonceAccount = exports.parseAccountUnified = exports.u64leDiscriminator = exports.PUMPSWAP_DISC = exports.PROGRAM_LOG_DISC = exports.parseMeteoraDammLog = void 0;
+exports.high_throughput_shred_stream_config = exports.low_latency_shred_stream_config = exports.default_shred_stream_config = exports.highThroughputShredStreamConfig = exports.lowLatencyShredStreamConfig = exports.defaultShredStreamConfig = exports.wireBytesToShredWasmTx = exports.decodeShredstreamEntriesBincode = exports.decodeEntriesBincodeNested = exports.decodeEntriesBincodeFlat = exports.bincodeVecEntryCount = exports.loadAddressLookupTableAccounts = exports.fullAccountKeyStringsFromShredTx = exports.dexEventsFromShredWasmTxWithFullKeys = exports.dexEventsFromShredWasmTx = exports.ShredEventQueue = exports.ShredStreamClient = void 0;
 var constants_js_1 = require("./common/constants.js");
 Object.defineProperty(exports, "DEFAULT_CHANNEL_SIZE", { enumerable: true, get: function () { return constants_js_1.DEFAULT_CHANNEL_SIZE; } });
 Object.defineProperty(exports, "DEFAULT_CONNECT_TIMEOUT", { enumerable: true, get: function () { return constants_js_1.DEFAULT_CONNECT_TIMEOUT; } });
@@ -162,11 +162,13 @@ Object.defineProperty(exports, "METEORA_DLMM_PROGRAM_ID", { enumerable: true, ge
 Object.defineProperty(exports, "METEORA_DBC_PROGRAM_ID", { enumerable: true, get: function () { return program_ids_js_1.METEORA_DBC_PROGRAM_ID; } });
 Object.defineProperty(exports, "getProgramIdsForProtocols", { enumerable: true, get: function () { return program_ids_js_1.getProgramIdsForProtocols; } });
 Object.defineProperty(exports, "transactionFilterForProtocols", { enumerable: true, get: function () { return program_ids_js_1.transactionFilterForProtocols; } });
+Object.defineProperty(exports, "transactionFilterForProtocolAccounts", { enumerable: true, get: function () { return program_ids_js_1.transactionFilterForProtocolAccounts; } });
 Object.defineProperty(exports, "accountFilterForProtocols", { enumerable: true, get: function () { return program_ids_js_1.accountFilterForProtocols; } });
 var program_ids_js_2 = require("./grpc/program_ids.js");
 Object.defineProperty(exports, "protocol_program_ids", { enumerable: true, get: function () { return program_ids_js_2.PROTOCOL_PROGRAM_IDS; } });
 Object.defineProperty(exports, "get_program_ids_for_protocols", { enumerable: true, get: function () { return program_ids_js_2.getProgramIdsForProtocols; } });
 Object.defineProperty(exports, "transaction_filter_for_protocols", { enumerable: true, get: function () { return program_ids_js_2.transactionFilterForProtocols; } });
+Object.defineProperty(exports, "transaction_filter_for_protocol_accounts", { enumerable: true, get: function () { return program_ids_js_2.transactionFilterForProtocolAccounts; } });
 Object.defineProperty(exports, "account_filter_for_protocols", { enumerable: true, get: function () { return program_ids_js_2.accountFilterForProtocols; } });
 /** Rust `grpc::types` 蛇形命名别名 */
 var types_js_3 = require("./grpc/types.js");

package/dist/rpc_transaction.js

@@ -30,6 +30,19 @@ const PUMPFUN_TRADE_EVENT_NAMES = new Set([
 ]);
 const EVENT_CPI_PREFIX = Uint8Array.from([228, 69, 165, 46, 81, 203, 154, 29]);
 const LEGACY_EVENT_CPI_SUFFIX = Uint8Array.from([155, 167, 108, 32, 122, 76, 173, 64]);
+const SUPPORTED_INSTRUCTION_PROGRAM_IDS = new Set([
+    program_ids_js_1.PUMPFUN_PROGRAM_ID,
+    program_ids_js_1.PUMPSWAP_PROGRAM_ID,
+    program_ids_js_1.PUMP_FEES_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_LAUNCHLAB_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_CPMM_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_CLMM_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_AMM_V4_PROGRAM_ID,
+    program_ids_js_1.ORCA_WHIRLPOOL_PROGRAM_ID,
+    program_ids_js_1.METEORA_POOLS_PROGRAM_ID,
+    program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID,
+    program_ids_js_1.METEORA_DLMM_PROGRAM_ID,
+]);
 function bytesEqualAt(data, expected, offset) {
     for (let i = 0; i < expected.length; i++) {
         if (data[offset + i] !== expected[i])
@@ -379,6 +392,8 @@ function parseOuterAndInnerInstructions(message, meta, signature, slot, txIndex,
         const programId = (0, rpc_invoke_map_js_1.accountKeyToBase58)(resolver.get(ix.programIdIndex));
         if (!programId)
             continue;
+        if (!SUPPORTED_INSTRUCTION_PROGRAM_IDS.has(programId))
+            continue;
         const data = (0, rpc_invoke_map_js_1.decodeIxData)(ix.data);
         const accounts = resolveAccounts(resolver, ix.accountKeyIndexes);
         const ev = (0, mod_js_1.parseInstructionUnified)(data, accounts, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, programId);
@@ -399,6 +414,8 @@ function parseOuterAndInnerInstructions(message, meta, signature, slot, txIndex,
             const programId = (0, rpc_invoke_map_js_1.accountKeyToBase58)(resolver.get(ix.programIdIndex));
             if (!programId)
                 continue;
+            if (!SUPPORTED_INSTRUCTION_PROGRAM_IDS.has(programId))
+                continue;
             const data = (0, rpc_invoke_map_js_1.decodeIxData)(ix.data);
             const accounts = resolveAccounts(resolver, ix.accounts);
             const ev = (0, inner_js_1.parseInnerCompiledInstructionIfSupported)(data, accounts, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, programId) ??
@@ -493,8 +510,7 @@ function parseRpcTransaction(tx, signature, filter, options) {
                 activeProgramStack.length = idx;
         }
     }
-    applyRpcFills(instructionEvents, msg, meta);
-    applyRpcFills(logEvents, msg, meta);
+    applyRpcFills([...instructionEvents, ...logEvents], msg, meta);
     const events = (0, log_instr_dedup_js_1.dedupeLogInstructionEvents)(logEvents, instructionEvents);
     (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(events);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol-parser-sdk",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "High-performance Solana DEX event parser for Node.js/TypeScript (Yellowstone gRPC, log parsing)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,6 +32,8 @@
     "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:grpc:devtrades": "tsx examples/devtrades_low_latency.ts",
+    "example:grpc:devtrades:pumpswap": "tsx examples/devtrades_pumpfun_pumpswap_low_latency.ts",
+    "example:grpc:pumpswap": "tsx examples/pumpswap_low_latency.ts",
     "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",