sol-parser-sdk-nodejs 0.3.0 → 0.4.4

package/dist/grpc/client.js

@@ -32,22 +32,80 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YellowstoneGrpc = void 0;
 /**
  * Yellowstone gRPC 客户端实现 - 基于 @triton-one/yellowstone-grpc
  */
 const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
+const bs58_1 = __importDefault(require("bs58"));
+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");
+const order_buffer_js_1 = require("./order_buffer.js");
+const subscribe_builder_js_1 = require("./subscribe_builder.js");
+const yellowstone_parse_js_1 = require("./yellowstone_parse.js");
 const types_js_1 = require("./types.js");
+class AsyncEventQueue {
+    maxSize;
+    items = [];
+    waiters = [];
+    closed = false;
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    push(item) {
+        if (this.closed)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({ value: item, done: false });
+            return;
+        }
+        if (this.items.length < this.maxSize) {
+            this.items.push(item);
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0)) {
+            waiter({ value: undefined, done: true });
+        }
+    }
+    next() {
+        const item = this.items.shift();
+        if (item !== undefined) {
+            return Promise.resolve({ value: item, done: false });
+        }
+        if (this.closed) {
+            return Promise.resolve({ value: undefined, done: true });
+        }
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+}
 /** Yellowstone gRPC 客户端包装器 */
 class YellowstoneGrpc {
     client;
     config;
     connected = false;
     subscribers = new Map();
+    dexSubscribers = new Map();
     constructor(endpoint, xToken, config = (0, types_js_1.defaultClientConfig)()) {
         this.config = config;
-        this.client = new yellowstone_grpc_1.default(endpoint, xToken || undefined, undefined);
+        const gc = (0, geyser_connect_js_1.defaultGeyserConnectConfig)();
+        this.client = new yellowstone_grpc_1.default(endpoint, xToken || undefined, (0, geyser_connect_js_1.geyserGrpcChannelOptions)({
+            ...gc,
+            keepAliveIntervalMs: config.keep_alive_interval_ms,
+            keepAliveTimeoutMs: config.keep_alive_timeout_ms,
+        }));
     }
     /** 连接到 gRPC 服务器 */
     async connect() {
@@ -62,6 +120,10 @@ class YellowstoneGrpc {
             sub.cancel();
         }
         this.subscribers.clear();
+        for (const [, sub] of this.dexSubscribers) {
+            sub.cancel();
+        }
+        this.dexSubscribers.clear();
         this.connected = false;
     }
     /** 检查是否已连接 */
@@ -90,6 +152,9 @@ class YellowstoneGrpc {
         const result = {
             filters: update.filters,
         };
+        const createdAtUs = YellowstoneGrpc.timestampToMicros(update.createdAt ?? update.created_at);
+        if (createdAtUs !== undefined)
+            result.createdAtUs = createdAtUs;
         if (update.account) {
             const acc = update.account;
             result.account = {
@@ -167,89 +232,192 @@ class YellowstoneGrpc {
         }
         return result;
     }
+    /**
+     * 应答 Geyser 在 SubscribeUpdate 中下发的 ping（与 `solana-streamer` / Rust 侧一致）。
+     * 若不回复，公共节点或 LB 可能在超时后 RST_STREAM（HTTP/2 CANCEL）。
+     */
+    subscribePingPongRequest() {
+        return {
+            accounts: {},
+            slots: {},
+            transactions: {},
+            transactionsStatus: {},
+            entry: {},
+            blocks: {},
+            blocksMeta: {},
+            commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
+            accountsDataSlice: [],
+            ping: { id: 1 },
+        };
+    }
+    static toBytes(value) {
+        if (!value)
+            return new Uint8Array();
+        return value instanceof Uint8Array ? value : Uint8Array.from(value);
+    }
+    static toBigInt(value) {
+        return typeof value === "bigint" ? value : BigInt(value);
+    }
+    static protobufNumber(value) {
+        if (typeof value === "bigint")
+            return Number(value);
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string")
+            return Number(value);
+        if (value && typeof value === "object") {
+            const longLike = value;
+            if (typeof longLike.toNumber === "function")
+                return longLike.toNumber();
+            if (typeof longLike.toString === "function")
+                return Number(longLike.toString());
+        }
+        return Number.NaN;
+    }
+    static timestampToMicros(value) {
+        if (!value || typeof value !== "object")
+            return undefined;
+        const ts = value;
+        if (ts.seconds === undefined)
+            return undefined;
+        const seconds = YellowstoneGrpc.protobufNumber(ts.seconds);
+        const nanos = Number(ts.nanos ?? 0);
+        if (!Number.isFinite(seconds) || !Number.isFinite(nanos))
+            return undefined;
+        return Math.trunc(seconds * 1_000_000 + nanos / 1_000);
+    }
+    parseAccountEvent(update, grpcRecvUs, eventTypeFilter, blockTimeUs) {
+        const acc = update.account;
+        if (!acc)
+            return null;
+        const signatureBytes = YellowstoneGrpc.toBytes(acc.txnSignature);
+        const account = {
+            pubkey: bs58_1.default.encode(YellowstoneGrpc.toBytes(acc.pubkey)),
+            executable: acc.executable,
+            lamports: YellowstoneGrpc.toBigInt(acc.lamports),
+            owner: bs58_1.default.encode(YellowstoneGrpc.toBytes(acc.owner)),
+            rent_epoch: YellowstoneGrpc.toBigInt(acc.rentEpoch),
+            data: YellowstoneGrpc.toBytes(acc.data),
+        };
+        const metadata = (0, metadata_js_1.makeMetadata)(signatureBytes.length > 0 ? bs58_1.default.encode(signatureBytes) : "", Number(update.slot), 0, blockTimeUs, grpcRecvUs);
+        return (0, mod_js_1.parseAccountUnified)(account, metadata, eventTypeFilter);
+    }
+    initialSubscribeRequest(filter) {
+        return {
+            transactions: {
+                client: {
+                    accountInclude: filter.account_include,
+                    accountExclude: filter.account_exclude,
+                    accountRequired: filter.account_required,
+                    vote: filter.vote,
+                    failed: filter.failed,
+                    signature: filter.signature,
+                },
+            },
+            accounts: {},
+            slots: {},
+            transactionsStatus: {},
+            entry: {},
+            blocks: {},
+            blocksMeta: {},
+            commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
+            accountsDataSlice: [],
+            ping: undefined,
+        };
+    }
     /** 订阅交易 */
     async subscribeTransactions(filter, callbacks) {
         const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
         let isCancelled = false;
+        const streamHolder = { current: null };
         const cancel = () => {
             isCancelled = true;
+            streamHolder.current?.end();
+            streamHolder.current = null;
         };
         this.subscribers.set(id, { filter, callbacks, cancel });
         (async () => {
+            const autoReconnect = callbacks.autoReconnect !== false;
+            const maxBackoffMs = 60_000;
+            let backoffMs = this.config.retry_delay_ms;
             try {
-                const stream = await this.client.subscribe();
-                await new Promise((resolve, reject) => {
-                    stream.write({
-                        transactions: {
-                            client: {
-                                accountInclude: filter.account_include,
-                                accountExclude: filter.account_exclude,
-                                accountRequired: filter.account_required,
-                                vote: filter.vote,
-                                failed: filter.failed,
-                                signature: filter.signature,
-                            },
-                        },
-                        accounts: {},
-                        slots: {},
-                        transactionsStatus: {},
-                        entry: {},
-                        blocks: {},
-                        blocksMeta: {},
-                        commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
-                        accountsDataSlice: [],
-                        ping: undefined,
-                    }, (err) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve();
-                    });
-                });
-                stream.on("data", (update) => {
-                    if (isCancelled)
-                        return;
-                    if (!callbacks.onUpdate)
-                        return;
+                while (!isCancelled) {
                     try {
-                        const converted = this.convertUpdate(update);
-                        callbacks.onUpdate(converted);
+                        const stream = await this.client.subscribe();
+                        streamHolder.current = stream;
+                        await new Promise((resolve, reject) => {
+                            stream.write(this.initialSubscribeRequest(filter), (err) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                        backoffMs = this.config.retry_delay_ms;
+                        await new Promise((resolve, reject) => {
+                            const cleanup = () => {
+                                stream.removeAllListeners();
+                                if (streamHolder.current === stream) {
+                                    streamHolder.current = null;
+                                }
+                            };
+                            stream.on("data", (update) => {
+                                if (isCancelled)
+                                    return;
+                                if (update.ping) {
+                                    stream.write(this.subscribePingPongRequest(), (werr) => {
+                                        if (werr && callbacks.onError && !isCancelled) {
+                                            callbacks.onError(werr instanceof Error ? werr : new Error(String(werr)));
+                                        }
+                                    });
+                                    return;
+                                }
+                                if (!callbacks.onUpdate)
+                                    return;
+                                try {
+                                    const converted = this.convertUpdate(update);
+                                    callbacks.onUpdate(converted);
+                                }
+                                catch (err) {
+                                    const e = err instanceof Error ? err : new Error(String(err));
+                                    callbacks.onError?.(e);
+                                }
+                            });
+                            stream.on("error", (err) => {
+                                cleanup();
+                                reject(err);
+                            });
+                            stream.on("end", () => {
+                                cleanup();
+                                resolve();
+                            });
+                        });
                     }
                     catch (err) {
-                        // 用户 onUpdate 内抛错（如同步 IO/画图）若未捕获，会破坏 gRPC duplex 流并触发 RST_STREAM。
+                        if (isCancelled)
+                            break;
                         const e = err instanceof Error ? err : new Error(String(err));
-                        if (callbacks.onError) {
-                            callbacks.onError(e);
-                        }
+                        callbacks.onError?.(e);
+                        if (!autoReconnect)
+                            break;
+                        await new Promise((r) => setTimeout(r, backoffMs));
+                        backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                        continue;
                     }
-                });
-                stream.on("error", (err) => {
                     if (isCancelled)
-                        return;
-                    if (callbacks.onError) {
-                        callbacks.onError(err);
+                        break;
+                    if (!autoReconnect) {
+                        callbacks.onEnd?.();
+                        break;
                     }
-                });
-                stream.on("end", () => {
-                    if (isCancelled)
-                        return;
-                    this.subscribers.delete(id);
-                    if (callbacks.onEnd) {
-                        callbacks.onEnd();
-                    }
-                });
-                while (!isCancelled) {
-                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
                 }
-                stream.end();
             }
-            catch (err) {
-                if (isCancelled)
-                    return;
+            finally {
+                streamHolder.current?.end();
+                streamHolder.current = null;
                 this.subscribers.delete(id);
-                if (callbacks.onError) {
-                    callbacks.onError(err);
-                }
             }
         })();
         return {
@@ -260,6 +428,158 @@ class YellowstoneGrpc {
             },
         };
     }
+    /**
+     * 订阅并直接产出 `DexEvent`。
+     *
+     * 交易更新走统一交易解析（外层/内层指令 + 日志 + 数据填充）；账户更新走 `parseAccountUnified`。
+     * 事件队列满时丢弃新事件，避免回调阻塞 gRPC 读循环，保持低延迟。
+     */
+    async subscribeDexEvents(transactionFilters = [], accountFilters = [], eventTypeFilter, options) {
+        await this.connect();
+        const id = `dex_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        const events = new AsyncEventQueue(Math.max(1, this.config.buffer_size));
+        const errors = new AsyncEventQueue(Math.max(1, this.config.buffer_size));
+        const order = new order_buffer_js_1.OrderDispatcher(this.config);
+        const emitEvent = (event) => events.push(event);
+        let flushTimer;
+        if (order.needsTimer) {
+            const intervalMs = this.config.order_mode === "MicroBatch"
+                ? Math.max(1, Math.ceil(this.config.micro_batch_us / 1000))
+                : Math.max(1, Math.floor(this.config.order_timeout_ms / 2));
+            flushTimer = setInterval(() => order.flushDue(emitEvent), intervalMs);
+        }
+        let isCancelled = false;
+        let currentTransactionFilters = transactionFilters;
+        let currentAccountFilters = accountFilters;
+        const streamHolder = { current: null };
+        const cancel = () => {
+            isCancelled = true;
+            streamHolder.current?.end();
+            streamHolder.current = null;
+            if (flushTimer)
+                clearInterval(flushTimer);
+            events.close();
+            errors.close();
+        };
+        const update = async (nextTxFilters, nextAccFilters) => {
+            currentTransactionFilters = nextTxFilters;
+            currentAccountFilters = nextAccFilters;
+            const stream = streamHolder.current;
+            if (!stream)
+                return;
+            await new Promise((resolve, reject) => {
+                stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        };
+        this.dexSubscribers.set(id, { cancel, update });
+        (async () => {
+            const autoReconnect = options?.autoReconnect !== false;
+            const maxBackoffMs = 60_000;
+            let backoffMs = this.config.retry_delay_ms;
+            try {
+                while (!isCancelled) {
+                    try {
+                        const stream = await this.client.subscribe();
+                        streamHolder.current = stream;
+                        await new Promise((resolve, reject) => {
+                            stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                        backoffMs = this.config.retry_delay_ms;
+                        await new Promise((resolve, reject) => {
+                            const cleanup = () => {
+                                stream.removeAllListeners();
+                                if (streamHolder.current === stream) {
+                                    streamHolder.current = null;
+                                }
+                            };
+                            stream.on("data", (update) => {
+                                if (isCancelled)
+                                    return;
+                                order.flushDue(emitEvent);
+                                if (update.ping) {
+                                    stream.write(this.subscribePingPongRequest(), (werr) => {
+                                        if (werr && !isCancelled) {
+                                            errors.push(werr instanceof Error ? werr : new Error(String(werr)));
+                                        }
+                                    });
+                                    return;
+                                }
+                                try {
+                                    const grpcRecvUs = Math.floor(Date.now() * 1000);
+                                    const converted = this.convertUpdate(update);
+                                    const tx = converted.transaction?.transaction;
+                                    if (tx) {
+                                        const fallbackSlot = YellowstoneGrpc.protobufNumber(converted.transaction?.slot ?? 0);
+                                        const fallbackTxIndex = YellowstoneGrpc.protobufNumber(tx.index ?? 0);
+                                        const txEvents = (0, yellowstone_parse_js_1.parseDexEventsFromGrpcTransactionInfo)(tx, converted.transaction?.slot ?? 0n, { blockTimeUs: converted.createdAtUs, grpcRecvUs, eventTypeFilter });
+                                        order.pushTransactionEvents(txEvents, fallbackSlot, fallbackTxIndex, emitEvent);
+                                    }
+                                    if (converted.account) {
+                                        const ev = this.parseAccountEvent(converted.account, grpcRecvUs, eventTypeFilter, converted.createdAtUs);
+                                        if (ev)
+                                            emitEvent(ev);
+                                    }
+                                }
+                                catch (err) {
+                                    errors.push(err instanceof Error ? err : new Error(String(err)));
+                                }
+                            });
+                            stream.on("error", (err) => {
+                                cleanup();
+                                reject(err);
+                            });
+                            stream.on("end", () => {
+                                cleanup();
+                                resolve();
+                            });
+                        });
+                    }
+                    catch (err) {
+                        if (isCancelled)
+                            break;
+                        errors.push(err instanceof Error ? err : new Error(String(err)));
+                        if (!autoReconnect)
+                            break;
+                        await new Promise((r) => setTimeout(r, backoffMs));
+                        backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                        continue;
+                    }
+                    if (isCancelled || !autoReconnect)
+                        break;
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                }
+            }
+            finally {
+                streamHolder.current?.end();
+                streamHolder.current = null;
+                if (flushTimer)
+                    clearInterval(flushTimer);
+                order.flushAll(emitEvent);
+                events.close();
+                errors.close();
+                this.dexSubscribers.delete(id);
+            }
+        })();
+        return Object.assign(events, {
+            id,
+            errors,
+            cancel: () => {
+                cancel();
+                this.dexSubscribers.delete(id);
+            },
+        });
+    }
     /** 取消订阅 */
     unsubscribe(subId) {
         const sub = this.subscribers.get(subId);
@@ -267,6 +587,22 @@ class YellowstoneGrpc {
             sub.cancel();
             this.subscribers.delete(subId);
         }
+        const dexSub = this.dexSubscribers.get(subId);
+        if (dexSub) {
+            dexSub.cancel();
+            this.dexSubscribers.delete(subId);
+        }
+    }
+    /** 动态更新当前 DEX 订阅过滤器（与 Rust update_subscription 语义对齐）。 */
+    async updateSubscription(transactionFilters, accountFilters) {
+        const active = this.dexSubscribers.values().next().value;
+        if (!active?.update) {
+            throw new Error("No active DEX subscription");
+        }
+        await active.update(transactionFilters, accountFilters);
+    }
+    async update_subscription(transactionFilters, accountFilters) {
+        await this.updateSubscription(transactionFilters, accountFilters);
     }
     /** 获取最新区块哈希 */
     async getLatestBlockhash(commitment) {

package/dist/grpc/event_parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 与 Rust `grpc::event_parser`（`pub use crate::core as event_parser`）对应：核心解析子集再导出。
+ */
+export { parseTransactionEvents, parseLogsOnly, parseTransactionWithListener, parseTransactionEventsStreaming, parseLogsStreaming, parseTransactionWithStreamingListener, parseLog, nowUs, type EventListener, type StreamingEventListener, } from "../core/unified_parser.js";
+export type { DexEvent } from "../core/dex_event.js";
+export type { EventMetadata } from "../core/metadata.js";

package/dist/grpc/event_parser.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowUs = exports.parseLog = exports.parseTransactionWithStreamingListener = exports.parseLogsStreaming = exports.parseTransactionEventsStreaming = exports.parseTransactionWithListener = exports.parseLogsOnly = exports.parseTransactionEvents = void 0;
+/**
+ * 与 Rust `grpc::event_parser`（`pub use crate::core as event_parser`）对应：核心解析子集再导出。
+ */
+var unified_parser_js_1 = require("../core/unified_parser.js");
+Object.defineProperty(exports, "parseTransactionEvents", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionEvents; } });
+Object.defineProperty(exports, "parseLogsOnly", { enumerable: true, get: function () { return unified_parser_js_1.parseLogsOnly; } });
+Object.defineProperty(exports, "parseTransactionWithListener", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionWithListener; } });
+Object.defineProperty(exports, "parseTransactionEventsStreaming", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionEventsStreaming; } });
+Object.defineProperty(exports, "parseLogsStreaming", { enumerable: true, get: function () { return unified_parser_js_1.parseLogsStreaming; } });
+Object.defineProperty(exports, "parseTransactionWithStreamingListener", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionWithStreamingListener; } });
+Object.defineProperty(exports, "parseLog", { enumerable: true, get: function () { return unified_parser_js_1.parseLog; } });
+Object.defineProperty(exports, "nowUs", { enumerable: true, get: function () { return unified_parser_js_1.nowUs; } });

package/dist/grpc/geyser_connect.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 与 Rust `sol-parser-sdk/src/grpc/geyser_connect.rs` 对齐：Yellowstone Geyser gRPC 连接选项。
+ *
+ * `@triton-one/yellowstone-grpc` 的 `Client` 通过构造函数第三参传入 `ChannelOptions`；
+ * `connectTimeoutMs` 无与 tonic 完全一一对应的项，仅作文档与默认值对齐（可配合环境网络调优）。
+ */
+import type { ChannelOptions } from "@grpc/grpc-js";
+import Client from "@triton-one/yellowstone-grpc";
+/** 与 Rust `GeyserConnectConfig` 字段对应（毫秒 / 字节） */
+export interface GeyserConnectConfig {
+    /** 对应 Rust `connect_timeout`（毫秒） */
+    connectTimeoutMs: number;
+    /** 对应 Rust `max_decoding_message_size` */
+    maxDecodingMessageSize: number;
+    /** 对应 Rust `x_token` */
+    xToken?: string;
+    /** gRPC 通道 HTTP/2 keepalive 间隔（毫秒），与 Rust `ClientConfig.keep_alive_interval_ms` 默认对齐 */
+    keepAliveIntervalMs?: number;
+    /** gRPC keepalive 应答超时（毫秒） */
+    keepAliveTimeoutMs?: number;
+}
+/** 与 Rust `GeyserConnectConfig::default` 一致 */
+export declare function defaultGeyserConnectConfig(): GeyserConnectConfig;
+/** 与 `ClientConfig` / `grpc.keepalive_*` 对齐，用于长连接抗 NAT/负载均衡 idle 断开 */
+export declare function geyserGrpcChannelOptions(config?: GeyserConnectConfig): ChannelOptions;
+/**
+ * 建立 Yellowstone Geyser 客户端（与 Rust `connect_yellowstone_geyser` 一致）。
+ * Rust 为 async；此处构造同步完成，返回 `Promise` 以保持 `await connectYellowstoneGeyser(...)` 写法。
+ */
+export declare function connectYellowstoneGeyser(endpoint: string, config?: GeyserConnectConfig): Promise<Client>;

package/dist/grpc/geyser_connect.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultGeyserConnectConfig = defaultGeyserConnectConfig;
+exports.geyserGrpcChannelOptions = geyserGrpcChannelOptions;
+exports.connectYellowstoneGeyser = connectYellowstoneGeyser;
+const yellowstone_grpc_1 = __importDefault(require("@triton-one/yellowstone-grpc"));
+/** 与 Rust `GeyserConnectConfig::default` 一致 */
+function defaultGeyserConnectConfig() {
+    return {
+        connectTimeoutMs: 8000,
+        maxDecodingMessageSize: 1024 * 1024 * 1024,
+        xToken: undefined,
+        keepAliveIntervalMs: 30_000,
+        keepAliveTimeoutMs: 5000,
+    };
+}
+/** 与 `ClientConfig` / `grpc.keepalive_*` 对齐，用于长连接抗 NAT/负载均衡 idle 断开 */
+function geyserGrpcChannelOptions(config = defaultGeyserConnectConfig()) {
+    const max = config.maxDecodingMessageSize;
+    const interval = config.keepAliveIntervalMs ?? 30_000;
+    const timeout = config.keepAliveTimeoutMs ?? 5000;
+    return {
+        "grpc.max_receive_message_length": max,
+        "grpc.max_send_message_length": max,
+        "grpc.keepalive_time_ms": interval,
+        "grpc.keepalive_timeout_ms": timeout,
+        /** 无活跃 RPC 时仍发 keepalive，避免长时间仅订阅时被中间设备掐断 */
+        "grpc.keepalive_permit_without_calls": 1,
+    };
+}
+/**
+ * 建立 Yellowstone Geyser 客户端（与 Rust `connect_yellowstone_geyser` 一致）。
+ * Rust 为 async；此处构造同步完成，返回 `Promise` 以保持 `await connectYellowstoneGeyser(...)` 写法。
+ */
+async function connectYellowstoneGeyser(endpoint, config = defaultGeyserConnectConfig()) {
+    return new yellowstone_grpc_1.default(endpoint, config.xToken, geyserGrpcChannelOptions(config));
+}

package/dist/grpc/log_instr_dedup.d.ts

@@ -0,0 +1,2 @@
+import type { DexEvent } from "../core/dex_event.js";
+export declare function dedupeLogInstructionEvents(logEvents: DexEvent[], instructionEvents: DexEvent[]): DexEvent[];