sol-parser-sdk-nodejs 0.3.0 → 0.4.0

package/dist/core/account_dispatcher_rpc.js

@@ -18,6 +18,24 @@ function tryFill(programId, programInvokes, message, meta, resolver, fn) {
         return;
     fn(get);
 }
+const BONK_PROGRAM_FILL_ORDER = [
+    program_ids_js_1.BONK_PROGRAM_ID,
+    program_ids_js_1.BONK_LAUNCHPAD_PROGRAM_ID,
+    program_ids_js_1.BONK_PROGRAM_ID_LEGACY,
+];
+/** Bonk 多程序 ID：按 Rust 主网 ID → Launchpad → 旧 TS 兼容顺序尝试 CPI 账户填充 */
+function tryFillBonk(programInvokes, message, meta, resolver, fn) {
+    for (const programId of BONK_PROGRAM_FILL_ORDER) {
+        const invoke = (0, rpc_invoke_map_js_1.findMaxAccountsInvoke)(programId, programInvokes, message, meta);
+        if (!invoke)
+            continue;
+        const get = (0, rpc_invoke_map_js_1.makeInvokeAccountGetter)(resolver, invoke, message, meta);
+        if (!get)
+            continue;
+        fn(get);
+        return;
+    }
+}
 /** 就地修改事件体内字段 */
 function fillAccountsFromTransactionDataRpc(ev, message, meta, programInvokes, resolver) {
     if ("PumpFunTrade" in ev) {
@@ -116,18 +134,21 @@ function fillAccountsFromTransactionDataRpc(ev, message, meta, programInvokes, r
     else if ("MeteoraDammV2CreatePosition" in ev) {
         tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2CreatePositionAccounts)(ev.MeteoraDammV2CreatePosition, g));
     }
+    else if ("MeteoraDammV2InitializePool" in ev) {
+        tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2InitializePoolAccounts)(ev.MeteoraDammV2InitializePool, g));
+    }
     else if ("MeteoraDammV2ClosePosition" in ev) {
         tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2ClosePositionAccounts)(ev.MeteoraDammV2ClosePosition, g));
     }
     else if ("MeteoraDammV2AddLiquidity" in ev) {
         tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2AddLiquidityAccounts)(ev.MeteoraDammV2AddLiquidity, g));
     }
+    else if ("MeteoraDammV2RemoveAllLiquidity" in ev) {
+        tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2RemoveAllLiquidityAccounts)(ev.MeteoraDammV2RemoveAllLiquidity, g));
+    }
     else if ("MeteoraDammV2RemoveLiquidity" in ev) {
         tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2RemoveLiquidityAccounts)(ev.MeteoraDammV2RemoveLiquidity, g));
     }
-    else if ("MeteoraDammV2InitializePool" in ev) {
-        tryFill(program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDammV2InitializePoolAccounts)(ev.MeteoraDammV2InitializePool, g));
-    }
     else if ("MeteoraPoolsSwap" in ev) {
         tryFill(program_ids_js_1.METEORA_POOLS_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraPoolsSwapAccounts)(ev.MeteoraPoolsSwap, g));
     }
@@ -147,9 +168,9 @@ function fillAccountsFromTransactionDataRpc(ev, message, meta, programInvokes, r
         tryFill(program_ids_js_1.METEORA_DLMM_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_meteora_js_1.fillMeteoraDlmmRemoveLiquidityAccounts)(ev.MeteoraDlmmRemoveLiquidity, g));
     }
     else if ("BonkTrade" in ev) {
-        tryFill(program_ids_js_1.BONK_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_bonk_js_1.fillBonkTradeAccounts)(ev.BonkTrade, g));
+        tryFillBonk(programInvokes, message, meta, resolver, (g) => (0, account_fill_bonk_js_1.fillBonkTradeAccounts)(ev.BonkTrade, g));
     }
     else if ("BonkPoolCreate" in ev) {
-        tryFill(program_ids_js_1.BONK_PROGRAM_ID, programInvokes, message, meta, resolver, (g) => (0, account_fill_bonk_js_1.fillBonkPoolCreateAccounts)(ev.BonkPoolCreate, g));
+        tryFillBonk(programInvokes, message, meta, resolver, (g) => (0, account_fill_bonk_js_1.fillBonkPoolCreateAccounts)(ev.BonkPoolCreate, g));
     }
 }

package/dist/core/account_fill_meteora.d.ts

@@ -1,11 +1,13 @@
 /** Meteora DAMM V2 / Pools / DLMM 账户填充（部分占位） */
-import type { MeteoraDammV2AddLiquidityEvent, MeteoraDammV2ClosePositionEvent, MeteoraDammV2CreatePositionEvent, MeteoraDammV2InitializePoolEvent, MeteoraDammV2RemoveLiquidityEvent, MeteoraDammV2SwapEvent, MeteoraDlmmAddLiquidityEvent, MeteoraDlmmRemoveLiquidityEvent, MeteoraDlmmSwapEvent, MeteoraPoolsAddLiquidityEvent, MeteoraPoolsRemoveLiquidityEvent, MeteoraPoolsSwapEvent } from "./dex_event.js";
+import type { MeteoraDammV2AddLiquidityEvent, MeteoraDammV2ClosePositionEvent, MeteoraDammV2CreatePositionEvent, MeteoraDammV2InitializePoolEvent, MeteoraDammV2RemoveAllLiquidityEvent, MeteoraDammV2RemoveLiquidityEvent, MeteoraDammV2SwapEvent, MeteoraDlmmAddLiquidityEvent, MeteoraDlmmRemoveLiquidityEvent, MeteoraDlmmSwapEvent, MeteoraPoolsAddLiquidityEvent, MeteoraPoolsRemoveLiquidityEvent, MeteoraPoolsSwapEvent } from "./dex_event.js";
+/** 预留：gRPC+meta 全量路径若需从 account_keys 补 vault，应对齐 cp_amm `swap` 账户顺序（IDL 中 vault/mint/token program 下标） */
 export declare function fillMeteoraDammV2SwapAccounts(_e: MeteoraDammV2SwapEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraDammV2CreatePositionAccounts(_e: MeteoraDammV2CreatePositionEvent, _get: (i: number) => string): void;
+export declare function fillMeteoraDammV2InitializePoolAccounts(_e: MeteoraDammV2InitializePoolEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraDammV2ClosePositionAccounts(_e: MeteoraDammV2ClosePositionEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraDammV2AddLiquidityAccounts(_e: MeteoraDammV2AddLiquidityEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraDammV2RemoveLiquidityAccounts(_e: MeteoraDammV2RemoveLiquidityEvent, _get: (i: number) => string): void;
-export declare function fillMeteoraDammV2InitializePoolAccounts(_e: MeteoraDammV2InitializePoolEvent, _get: (i: number) => string): void;
+export declare function fillMeteoraDammV2RemoveAllLiquidityAccounts(_e: MeteoraDammV2RemoveAllLiquidityEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraPoolsSwapAccounts(_e: MeteoraPoolsSwapEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraPoolsAddLiquidityAccounts(_e: MeteoraPoolsAddLiquidityEvent, _get: (i: number) => string): void;
 export declare function fillMeteoraPoolsRemoveLiquidityAccounts(_e: MeteoraPoolsRemoveLiquidityEvent, _get: (i: number) => string): void;

package/dist/core/account_fill_meteora.js

@@ -2,22 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fillMeteoraDammV2SwapAccounts = fillMeteoraDammV2SwapAccounts;
 exports.fillMeteoraDammV2CreatePositionAccounts = fillMeteoraDammV2CreatePositionAccounts;
+exports.fillMeteoraDammV2InitializePoolAccounts = fillMeteoraDammV2InitializePoolAccounts;
 exports.fillMeteoraDammV2ClosePositionAccounts = fillMeteoraDammV2ClosePositionAccounts;
 exports.fillMeteoraDammV2AddLiquidityAccounts = fillMeteoraDammV2AddLiquidityAccounts;
 exports.fillMeteoraDammV2RemoveLiquidityAccounts = fillMeteoraDammV2RemoveLiquidityAccounts;
-exports.fillMeteoraDammV2InitializePoolAccounts = fillMeteoraDammV2InitializePoolAccounts;
+exports.fillMeteoraDammV2RemoveAllLiquidityAccounts = fillMeteoraDammV2RemoveAllLiquidityAccounts;
 exports.fillMeteoraPoolsSwapAccounts = fillMeteoraPoolsSwapAccounts;
 exports.fillMeteoraPoolsAddLiquidityAccounts = fillMeteoraPoolsAddLiquidityAccounts;
 exports.fillMeteoraPoolsRemoveLiquidityAccounts = fillMeteoraPoolsRemoveLiquidityAccounts;
 exports.fillMeteoraDlmmSwapAccounts = fillMeteoraDlmmSwapAccounts;
 exports.fillMeteoraDlmmAddLiquidityAccounts = fillMeteoraDlmmAddLiquidityAccounts;
 exports.fillMeteoraDlmmRemoveLiquidityAccounts = fillMeteoraDlmmRemoveLiquidityAccounts;
+/** 预留：gRPC+meta 全量路径若需从 account_keys 补 vault，应对齐 cp_amm `swap` 账户顺序（IDL 中 vault/mint/token program 下标） */
 function fillMeteoraDammV2SwapAccounts(_e, _get) { }
 function fillMeteoraDammV2CreatePositionAccounts(_e, _get) { }
+function fillMeteoraDammV2InitializePoolAccounts(_e, _get) { }
 function fillMeteoraDammV2ClosePositionAccounts(_e, _get) { }
 function fillMeteoraDammV2AddLiquidityAccounts(_e, _get) { }
 function fillMeteoraDammV2RemoveLiquidityAccounts(_e, _get) { }
-function fillMeteoraDammV2InitializePoolAccounts(_e, _get) { }
+function fillMeteoraDammV2RemoveAllLiquidityAccounts(_e, _get) { }
 function fillMeteoraPoolsSwapAccounts(_e, _get) { }
 function fillMeteoraPoolsAddLiquidityAccounts(_e, _get) { }
 function fillMeteoraPoolsRemoveLiquidityAccounts(_e, _get) { }

package/dist/core/account_pubkey_cache.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 与 Rust `sol-parser-sdk/src/core/cache.rs` 对齐：账户公钥索引解析缓存。
+ * JS 主线程单线程，使用模块级单例代替 Rust `thread_local`。
+ */
+import { PublicKey } from "@solana/web3.js";
+export declare class AccountPubkeyCache {
+    private readonly cache;
+    /** 与 Rust `AccountPubkeyCache::build_account_pubkeys` 一致 */
+    buildAccountPubkeys(instructionAccounts: Uint8Array | readonly number[], allAccounts: readonly PublicKey[]): PublicKey[];
+}
+/** 与 Rust `build_account_pubkeys_with_cache` 一致（返回 `Vec` 拷贝，与 Rust `.to_vec()` 相同） */
+export declare function buildAccountPubkeysWithCache(instructionAccounts: Uint8Array | readonly number[], allAccounts: readonly PublicKey[]): PublicKey[];

package/dist/core/account_pubkey_cache.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountPubkeyCache = void 0;
+exports.buildAccountPubkeysWithCache = buildAccountPubkeysWithCache;
+class AccountPubkeyCache {
+    cache = [];
+    /** 与 Rust `AccountPubkeyCache::build_account_pubkeys` 一致 */
+    buildAccountPubkeys(instructionAccounts, allAccounts) {
+        this.cache.length = 0;
+        for (let i = 0; i < instructionAccounts.length; i++) {
+            const idx = instructionAccounts[i];
+            if (idx < allAccounts.length) {
+                this.cache.push(allAccounts[idx]);
+            }
+        }
+        return this.cache;
+    }
+}
+exports.AccountPubkeyCache = AccountPubkeyCache;
+let threadLocalLike;
+/** 与 Rust `build_account_pubkeys_with_cache` 一致（返回 `Vec` 拷贝，与 Rust `.to_vec()` 相同） */
+function buildAccountPubkeysWithCache(instructionAccounts, allAccounts) {
+    if (!threadLocalLike)
+        threadLocalLike = new AccountPubkeyCache();
+    return [...threadLocalLike.buildAccountPubkeys(instructionAccounts, allAccounts)];
+}

package/dist/core/clock.d.ts

@@ -1,2 +1,8 @@
 /** 当前时间微秒戳（用于 `grpc_recv_us`） */
 export declare function nowUs(): number;
+/** 与 Rust `now_micros` 一致（别名） */
+export declare const nowMicros: typeof nowUs;
+/** 与 Rust `now_nanos` 同语义：墙钟纳秒（`Date` 精度为毫秒，纳秒位为推算值） */
+export declare function nowNanos(): bigint;
+/** 与 Rust `elapsed_micros_since` 一致 */
+export declare function elapsedMicrosSince(startUs: number): number;

package/dist/core/clock.js

@@ -1,7 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowMicros = void 0;
 exports.nowUs = nowUs;
+exports.nowNanos = nowNanos;
+exports.elapsedMicrosSince = elapsedMicrosSince;
 /** 当前时间微秒戳（用于 `grpc_recv_us`） */
 function nowUs() {
     return Math.floor(Date.now() * 1000);
 }
+/** 与 Rust `now_micros` 一致（别名） */
+exports.nowMicros = nowUs;
+/** 与 Rust `now_nanos` 同语义：墙钟纳秒（`Date` 精度为毫秒，纳秒位为推算值） */
+function nowNanos() {
+    return BigInt(Math.floor(Date.now() * 1_000_000));
+}
+/** 与 Rust `elapsed_micros_since` 一致 */
+function elapsedMicrosSince(startUs) {
+    return nowUs() - startUs;
+}

package/dist/core/dex_event.d.ts

@@ -87,11 +87,13 @@ export type DexEvent = {
 } | {
     MeteoraDammV2RemoveLiquidity: MeteoraDammV2RemoveLiquidityEvent;
 } | {
-    MeteoraDammV2CreatePosition: MeteoraDammV2CreatePositionEvent;
+    MeteoraDammV2RemoveAllLiquidity: MeteoraDammV2RemoveAllLiquidityEvent;
 } | {
-    MeteoraDammV2ClosePosition: MeteoraDammV2ClosePositionEvent;
+    MeteoraDammV2CreatePosition: MeteoraDammV2CreatePositionEvent;
 } | {
     MeteoraDammV2InitializePool: MeteoraDammV2InitializePoolEvent;
+} | {
+    MeteoraDammV2ClosePosition: MeteoraDammV2ClosePositionEvent;
 } | {
     MeteoraDlmmSwap: MeteoraDlmmSwapEvent;
 } | {
@@ -761,67 +763,46 @@ export interface MeteoraDammV2RemoveLiquidityEvent {
     token_a_amount_threshold: bigint;
     token_b_amount_threshold: bigint;
 }
-/** 与 `MeteoraDammV2CreatePositionEvent` 对齐 */
-export interface MeteoraDammV2CreatePositionEvent {
+/** 外层 `remove_all_liquidity`；指令仅含两 u64 阈值，无 `liquidity_delta`。 */
+export interface MeteoraDammV2RemoveAllLiquidityEvent {
     metadata: EventMetadata;
     pool: string;
-    owner: string;
     position: string;
-    position_nft_mint: string;
+    owner: string;
+    token_a_amount_threshold: bigint;
+    token_b_amount_threshold: bigint;
 }
-/** 与 `MeteoraDammV2ClosePositionEvent` 对齐 */
-export interface MeteoraDammV2ClosePositionEvent {
+/** 与 `MeteoraDammV2CreatePositionEvent` 对齐 */
+export interface MeteoraDammV2CreatePositionEvent {
     metadata: EventMetadata;
     pool: string;
     owner: string;
     position: string;
     position_nft_mint: string;
 }
-/** Meteora `cp-amm` `DynamicFeeParameters`（Anchor 序列化） */
-export interface MeteoraDammV2DynamicFeeParameters {
-    bin_step: number;
-    bin_step_u128: bigint;
-    filter_period: number;
-    decay_period: number;
-    reduction_factor: number;
-    max_volatility_accumulator: number;
-    variable_fee_control: number;
-}
-/** Meteora `cp-amm` `PoolFeeParameters`（Anchor 序列化解析） */
-export interface MeteoraDammV2PoolFeeParameters {
-    /** `BaseFeeParameters.data`，27 字节十六进制 */
-    base_fee_data: string;
-    compounding_fee_bps: number;
-    padding: number;
-    dynamic_fee: MeteoraDammV2DynamicFeeParameters | null;
-}
 /**
- * 与 Meteora `cp-amm` `EvtInitializePool` 对齐（Program data 载荷）。
- * Go/Python 中 `sqrt_min_price`、`liquidity`、`pool_fees.dynamic_fee.bin_step_u128` 等 u128 语义字段为十进制字符串。
+ * 外层 `initialize_pool`（`InitializePoolParameters`）；无日志时仅含指令内字段与账户索引映射。
+ * Go/Python 中 `liquidity` / `sqrt_price` 为十进制字符串；`activation_point` 为 `None` 或十进制字符串。
  */
 export interface MeteoraDammV2InitializePoolEvent {
     metadata: EventMetadata;
+    creator: string;
+    position_nft_mint: string;
     pool: string;
+    position: string;
     token_a_mint: string;
     token_b_mint: string;
-    creator: string;
-    payer: string;
-    alpha_vault: string;
-    pool_fees: MeteoraDammV2PoolFeeParameters;
-    sqrt_min_price: bigint;
-    sqrt_max_price: bigint;
-    activation_type: number;
-    collect_fee_mode: number;
     liquidity: bigint;
     sqrt_price: bigint;
-    activation_point: bigint;
-    token_a_flag: number;
-    token_b_flag: number;
-    token_a_amount: bigint;
-    token_b_amount: bigint;
-    total_amount_a: bigint;
-    total_amount_b: bigint;
-    pool_type: number;
+    activation_point: bigint | null;
+}
+/** 与 `MeteoraDammV2ClosePositionEvent` 对齐 */
+export interface MeteoraDammV2ClosePositionEvent {
+    metadata: EventMetadata;
+    pool: string;
+    owner: string;
+    position: string;
+    position_nft_mint: string;
 }
 /** Meteora DLMM Swap：`fee_bps` 在 Go/Python 为十进制字符串。 */
 export interface MeteoraDlmmSwapEvent {

package/dist/core/metadata.d.ts

@@ -2,6 +2,7 @@
 export interface EventMetadata {
     signature: string;
     slot: number;
+    /** gRPC：与 Yellowstone `SubscribeUpdateTransactionInfo.index` 一致（Rust `info.index`）。Shred 等其它路径含义见各实现说明。 */
     tx_index: number;
     block_time_us: number;
     grpc_recv_us: number;

package/dist/core/unified_parser.d.ts

@@ -9,10 +9,10 @@ export type StreamingEventListener = {
 };
 /** 从交易解析事件；当前主路径为日志解析 */
 export declare function parseTransactionEvents(_instructionData: Uint8Array, _accounts: string[], logs: string[], signature: string, slot: number, _txIndex: number, blockTimeUs: number | undefined, _programId: string): DexEvent[];
-export declare function parseLogsOnly(logs: string[], signature: string, slot: number, blockTimeUs: number | undefined): DexEvent[];
+export declare function parseLogsOnly(logs: string[], signature: string, slot: number, blockTimeUs: number | undefined, txIndex?: number): DexEvent[];
 export declare function parseTransactionWithListener(instructionData: Uint8Array, accounts: string[], logs: string[], signature: string, slot: number, txIndex: number, blockTimeUs: number | undefined, programId: string, listener: EventListener): void;
 export declare function parseTransactionEventsStreaming(_instructionData: Uint8Array, _accounts: string[], logs: string[], signature: string, slot: number, _txIndex: number, blockTimeUs: number | undefined, _programId: string, callback: (event: DexEvent) => void): void;
-export declare function parseLogsStreaming(logs: string[], signature: string, slot: number, blockTimeUs: number | undefined, callback: (event: DexEvent) => void): void;
+export declare function parseLogsStreaming(logs: string[], signature: string, slot: number, blockTimeUs: number | undefined, callback: (event: DexEvent) => void, txIndex?: number): void;
 export declare function parseTransactionWithStreamingListener(instructionData: Uint8Array, accounts: string[], logs: string[], signature: string, slot: number, txIndex: number, blockTimeUs: number | undefined, programId: string, listener: StreamingEventListener): void;
 /** 带完整 gRPC 元数据字段的日志解析 */
 export declare function parseLog(log: string, signature: string, slot: number, txIndex: number, blockTimeUs: number | undefined, grpcRecvUs: number, eventTypeFilter: EventTypeFilter | undefined, isCreatedBuy: boolean, recentBlockhash?: Uint8Array): DexEvent | null;

package/dist/core/unified_parser.js

@@ -13,12 +13,12 @@ const clock_js_1 = require("./clock.js");
 Object.defineProperty(exports, "nowUs", { enumerable: true, get: function () { return clock_js_1.nowUs; } });
 /** 从交易解析事件；当前主路径为日志解析 */
 function parseTransactionEvents(_instructionData, _accounts, logs, signature, slot, _txIndex, blockTimeUs, _programId) {
-    return parseLogsOnly(logs, signature, slot, blockTimeUs);
+    return parseLogsOnly(logs, signature, slot, blockTimeUs, _txIndex);
 }
-function parseLogsOnly(logs, signature, slot, blockTimeUs) {
+function parseLogsOnly(logs, signature, slot, blockTimeUs, txIndex = 0) {
     const out = [];
     for (const log of logs) {
-        const e = (0, optimized_matcher_js_1.parseLogUnified)(log, signature, slot, blockTimeUs);
+        const e = (0, optimized_matcher_js_1.parseLogUnified)(log, signature, slot, blockTimeUs, txIndex);
         if (e)
             out.push(e);
     }
@@ -30,11 +30,11 @@ function parseTransactionWithListener(instructionData, accounts, logs, signature
     }
 }
 function parseTransactionEventsStreaming(_instructionData, _accounts, logs, signature, slot, _txIndex, blockTimeUs, _programId, callback) {
-    parseLogsStreaming(logs, signature, slot, blockTimeUs, callback);
+    parseLogsStreaming(logs, signature, slot, blockTimeUs, callback, _txIndex);
 }
-function parseLogsStreaming(logs, signature, slot, blockTimeUs, callback) {
+function parseLogsStreaming(logs, signature, slot, blockTimeUs, callback, txIndex = 0) {
     for (const log of logs) {
-        const e = (0, optimized_matcher_js_1.parseLogUnified)(log, signature, slot, blockTimeUs);
+        const e = (0, optimized_matcher_js_1.parseLogUnified)(log, signature, slot, blockTimeUs, txIndex);
         if (e)
             callback(e);
     }

package/dist/grpc/client.d.ts

@@ -23,6 +23,12 @@ export declare class YellowstoneGrpc {
     private convertSlotStatus;
     /** 转换订阅更新 */
     private convertUpdate;
+    /**
+     * 应答 Geyser 在 SubscribeUpdate 中下发的 ping（与 `solana-streamer` / Rust 侧一致）。
+     * 若不回复，公共节点或 LB 可能在超时后 RST_STREAM（HTTP/2 CANCEL）。
+     */
+    private subscribePingPongRequest;
+    private initialSubscribeRequest;
     /** 订阅交易 */
     subscribeTransactions(filter: TransactionFilter, callbacks: SubscribeCallbacks): Promise<{
         id: string;

package/dist/grpc/client.js

@@ -38,6 +38,7 @@ exports.YellowstoneGrpc = void 0;
  * Yellowstone gRPC 客户端实现 - 基于 @triton-one/yellowstone-grpc
  */
 const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
+const geyser_connect_js_1 = require("./geyser_connect.js");
 const types_js_1 = require("./types.js");
 /** Yellowstone gRPC 客户端包装器 */
 class YellowstoneGrpc {
@@ -47,7 +48,12 @@ class YellowstoneGrpc {
     subscribers = 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() {
@@ -167,89 +173,140 @@ 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 },
+        };
+    }
+    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);
-                        }
-                    }
-                });
-                stream.on("error", (err) => {
-                    if (isCancelled)
-                        return;
-                    if (callbacks.onError) {
-                        callbacks.onError(err);
+                        callbacks.onError?.(e);
+                        if (!autoReconnect)
+                            break;
+                        await new Promise((r) => setTimeout(r, backoffMs));
+                        backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                        continue;
                     }
-                });
-                stream.on("end", () => {
                     if (isCancelled)
-                        return;
-                    this.subscribers.delete(id);
-                    if (callbacks.onEnd) {
-                        callbacks.onEnd();
+                        break;
+                    if (!autoReconnect) {
+                        callbacks.onEnd?.();
+                        break;
                     }
-                });
-                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 {

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