sol-parser-sdk 0.5.9

package/dist/rpc_transaction.js

@@ -0,0 +1,416 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillDataRpc = exports.fillAccountsFromTransactionDataRpc = void 0;
+exports.applyAccountFillsToLogEvents = applyAccountFillsToLogEvents;
+exports.parseRpcTransaction = parseRpcTransaction;
+/**
+ * RPC 交易解析：外层 + 内层指令 → 日志 → `fillAccountsFromTransactionDataRpc` → `fillDataRpc`。
+ */
+const bs58_1 = __importDefault(require("bs58"));
+const web3_js_1 = require("@solana/web3.js");
+const types_js_1 = require("./grpc/types.js");
+const account_dispatcher_rpc_js_1 = require("./core/account_dispatcher_rpc.js");
+const common_filler_rpc_js_1 = require("./core/common_filler_rpc.js");
+const pumpfun_fee_enrich_js_1 = require("./core/pumpfun_fee_enrich.js");
+const rpc_invoke_map_js_1 = require("./core/rpc_invoke_map.js");
+const log_instr_dedup_js_1 = require("./grpc/log_instr_dedup.js");
+const inner_js_1 = require("./instr/inner.js");
+const mod_js_1 = require("./instr/mod.js");
+const optimized_matcher_js_1 = require("./logs/optimized_matcher.js");
+const DEFAULT_PK = web3_js_1.PublicKey.default.toBase58();
+function eventName(ev) {
+    return Object.keys(ev)[0] ?? "";
+}
+function eventPayload(ev) {
+    const name = eventName(ev);
+    return name ? ev[name] : null;
+}
+function isDefaultValue(v) {
+    return v == null || v === "" || v === DEFAULT_PK;
+}
+function putStringIfSet(to, key, from) {
+    const value = from[key];
+    if (!isDefaultValue(value))
+        to[key] = value;
+}
+function putNonZero(to, key, from) {
+    const value = from[key];
+    if (value !== undefined && value !== 0 && value !== 0n)
+        to[key] = value;
+}
+function fillStringIfEmpty(to, key, from) {
+    const value = from[key];
+    if (isDefaultValue(to[key]) && !isDefaultValue(value))
+        to[key] = value;
+}
+function mergePumpfunTradeInstruction(base, inner) {
+    const leg = inner.sol_amount !== 0n || inner.token_amount !== 0n;
+    for (const key of ["mint", "user", "fee_recipient", "creator"]) {
+        putStringIfSet(base, key, inner);
+    }
+    if (leg) {
+        for (const key of [
+            "sol_amount",
+            "token_amount",
+            "timestamp",
+            "virtual_sol_reserves",
+            "virtual_token_reserves",
+            "real_sol_reserves",
+            "real_token_reserves",
+            "fee_basis_points",
+            "fee",
+            "creator_fee_basis_points",
+            "creator_fee",
+            "total_unclaimed_tokens",
+            "total_claimed_tokens",
+            "current_sol_volume",
+            "last_update_timestamp",
+        ]) {
+            base[key] = inner[key];
+        }
+        base.is_buy = inner.is_buy;
+        base.track_volume = Boolean(base.track_volume) || Boolean(inner.track_volume);
+        base.mayhem_mode = Boolean(base.mayhem_mode) || Boolean(inner.mayhem_mode);
+        if ((base.shareholders?.length ?? 0) === 0 && (inner.shareholders?.length ?? 0) !== 0) {
+            base.shareholders = inner.shareholders;
+        }
+        if ((inner.ix_name ?? "") !== "")
+            base.ix_name = inner.ix_name;
+        base.is_cashback_coin = Boolean(base.is_cashback_coin) || Boolean(inner.is_cashback_coin);
+    }
+    else {
+        for (const key of [
+            "fee",
+            "creator_fee",
+            "fee_basis_points",
+            "creator_fee_basis_points",
+            "virtual_sol_reserves",
+            "virtual_token_reserves",
+            "real_sol_reserves",
+            "real_token_reserves",
+            "total_unclaimed_tokens",
+            "total_claimed_tokens",
+            "current_sol_volume",
+            "timestamp",
+            "last_update_timestamp",
+        ]) {
+            putNonZero(base, key, inner);
+        }
+        base.track_volume = Boolean(base.track_volume) || Boolean(inner.track_volume);
+        base.mayhem_mode = Boolean(base.mayhem_mode) || Boolean(inner.mayhem_mode);
+        base.is_cashback_coin = Boolean(base.is_cashback_coin) || Boolean(inner.is_cashback_coin);
+        if ((base.shareholders?.length ?? 0) === 0 && (inner.shareholders?.length ?? 0) !== 0) {
+            base.shareholders = inner.shareholders;
+        }
+        if ((inner.ix_name ?? "") !== "")
+            base.ix_name = inner.ix_name;
+    }
+    for (const key of [
+        "cashback_fee_basis_points",
+        "cashback",
+        "buyback_fee_basis_points",
+        "buyback_fee",
+        "quote_amount",
+        "virtual_quote_reserves",
+        "real_quote_reserves",
+        "amount",
+        "max_sol_cost",
+        "min_sol_output",
+        "spendable_sol_in",
+        "spendable_quote_in",
+        "min_tokens_out",
+    ]) {
+        putNonZero(base, key, inner);
+    }
+    for (const key of [
+        "quote_mint",
+        "global",
+        "bonding_curve",
+        "bonding_curve_v2",
+        "associated_bonding_curve",
+        "associated_user",
+        "system_program",
+        "token_program",
+        "quote_token_program",
+        "associated_token_program",
+        "creator_vault",
+        "associated_quote_fee_recipient",
+        "buyback_fee_recipient",
+        "associated_quote_buyback_fee_recipient",
+        "associated_quote_bonding_curve",
+        "associated_quote_user",
+        "associated_creator_vault",
+        "sharing_config",
+        "event_authority",
+        "program",
+        "global_volume_accumulator",
+        "user_volume_accumulator",
+        "associated_user_volume_accumulator",
+        "fee_config",
+        "fee_program",
+    ]) {
+        putStringIfSet(base, key, inner);
+    }
+    if (base.account == null && inner.account != null)
+        base.account = inner.account;
+    base.is_created_buy = Boolean(base.is_created_buy) || Boolean(inner.is_created_buy);
+}
+function mergePumpfunCreateV2Instruction(base, inner) {
+    for (const key of ["name", "symbol", "uri"])
+        fillStringIfEmpty(base, key, inner);
+    for (const key of [
+        "mint",
+        "bonding_curve",
+        "user",
+        "creator",
+        "token_program",
+        "quote_mint",
+        "quote_vault",
+        "quote_token_program",
+        "mint_authority",
+        "associated_bonding_curve",
+        "global",
+        "system_program",
+        "associated_token_program",
+        "mayhem_program_id",
+        "global_params",
+        "sol_vault",
+        "mayhem_state",
+        "mayhem_token_vault",
+        "event_authority",
+        "program",
+        "observed_fee_recipient",
+    ]) {
+        putStringIfSet(base, key, inner);
+    }
+    for (const key of [
+        "timestamp",
+        "virtual_token_reserves",
+        "virtual_sol_reserves",
+        "real_token_reserves",
+        "token_total_supply",
+        "virtual_quote_reserves",
+    ]) {
+        putNonZero(base, key, inner);
+    }
+    base.is_mayhem_mode = Boolean(base.is_mayhem_mode) || Boolean(inner.is_mayhem_mode);
+    base.is_cashback_enabled = Boolean(base.is_cashback_enabled) || Boolean(inner.is_cashback_enabled);
+    if ((inner.ix_name ?? "") !== "")
+        base.ix_name = inner.ix_name;
+}
+function mergePumpSwapBuySellInstruction(base, inner) {
+    const ix = { ...base };
+    Object.assign(base, inner);
+    for (const key of [
+        "base_mint",
+        "quote_mint",
+        "user_base_token_account",
+        "user_quote_token_account",
+        "pool_base_token_account",
+        "pool_quote_token_account",
+        "protocol_fee_recipient",
+        "protocol_fee_recipient_token_account",
+        "coin_creator_vault_ata",
+        "coin_creator_vault_authority",
+        "base_token_program",
+        "quote_token_program",
+        "pool_v2",
+        "fee_recipient",
+        "fee_recipient_quote_token_account",
+    ]) {
+        fillStringIfEmpty(base, key, ix);
+    }
+}
+function mergeInstructionEvent(base, inner) {
+    const baseName = eventName(base);
+    const innerName = eventName(inner);
+    const baseData = eventPayload(base);
+    const innerData = eventPayload(inner);
+    if (!baseData || !innerData)
+        return;
+    const pumpfunTradeNames = new Set([
+        "PumpFunTrade",
+        "PumpFunBuy",
+        "PumpFunSell",
+        "PumpFunBuyExactSolIn",
+    ]);
+    if (pumpfunTradeNames.has(baseName) && pumpfunTradeNames.has(innerName)) {
+        mergePumpfunTradeInstruction(baseData, innerData);
+        return;
+    }
+    if (baseName === "PumpFunCreateV2" && innerName === "PumpFunCreateV2") {
+        mergePumpfunCreateV2Instruction(baseData, innerData);
+        return;
+    }
+    if ((baseName === "PumpSwapBuy" && innerName === "PumpSwapBuy") ||
+        (baseName === "PumpSwapSell" && innerName === "PumpSwapSell")) {
+        mergePumpSwapBuySellInstruction(baseData, innerData);
+        return;
+    }
+    if (baseName === innerName) {
+        Object.assign(baseData, innerData);
+    }
+}
+function mergeInstructionEvents(events) {
+    if (events.length === 0)
+        return [];
+    events.sort((a, b) => {
+        if (a.outerIdx !== b.outerIdx)
+            return a.outerIdx - b.outerIdx;
+        const ak = a.innerIdx === null ? 0 : 1 + a.innerIdx;
+        const bk = b.innerIdx === null ? 0 : 1 + b.innerIdx;
+        return ak - bk;
+    });
+    const out = [];
+    let pending = null;
+    for (const item of events) {
+        if (item.innerIdx === null) {
+            if (pending)
+                out.push(pending.event);
+            pending = { outerIdx: item.outerIdx, event: item.event };
+            continue;
+        }
+        if (pending && pending.outerIdx === item.outerIdx) {
+            mergeInstructionEvent(pending.event, item.event);
+        }
+        else {
+            if (pending) {
+                out.push(pending.event);
+                pending = null;
+            }
+            out.push(item.event);
+        }
+    }
+    if (pending)
+        out.push(pending.event);
+    return out;
+}
+function resolveAccounts(resolver, indices) {
+    const idxs = indices instanceof Uint8Array ? Array.from(indices) : indices;
+    return idxs.map((i) => (0, rpc_invoke_map_js_1.accountKeyToBase58)(resolver.get(i)) ?? DEFAULT_PK);
+}
+function parseOuterAndInnerInstructions(message, meta, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, isCreatedBuy) {
+    const resolver = (0, rpc_invoke_map_js_1.getAccountKeyResolver)(message, meta);
+    const indexedEvents = [];
+    for (const [outerIdx, ix] of message.compiledInstructions.entries()) {
+        const programId = (0, rpc_invoke_map_js_1.accountKeyToBase58)(resolver.get(ix.programIdIndex));
+        if (!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);
+        if (ev)
+            indexedEvents.push({ outerIdx, innerIdx: null, event: ev });
+    }
+    const innerGroups = meta?.innerInstructions;
+    if (!innerGroups)
+        return mergeInstructionEvents(indexedEvents);
+    for (const group of innerGroups) {
+        for (const [innerIdx, ix] of group.instructions.entries()) {
+            const programId = (0, rpc_invoke_map_js_1.accountKeyToBase58)(resolver.get(ix.programIdIndex));
+            if (!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) ??
+                (0, inner_js_1.parseInnerInstructionUnified)(data, accounts, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, programId, isCreatedBuy);
+            if (ev)
+                indexedEvents.push({ outerIdx: group.index, innerIdx, event: ev });
+        }
+    }
+    return mergeInstructionEvents(indexedEvents);
+}
+function recentBlockhashBytes(recentBlockhash) {
+    try {
+        return Uint8Array.from(bs58_1.default.decode(recentBlockhash));
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectPumpfunCreateInLogs(logMessages, _signature, _slot, _txIndex, _blockTimeUs, _grpcRecvUs, _recentBlockhash) {
+    return logMessages.some((log) => log.includes("Program data: G3KpTd7rY3Y"));
+}
+function applyRpcFills(events, msg, meta) {
+    const resolver = (0, rpc_invoke_map_js_1.getAccountKeyResolver)(msg, meta);
+    const programInvokes = (0, rpc_invoke_map_js_1.buildProgramInvokesMap)(msg, meta, resolver);
+    for (const ev of events) {
+        (0, account_dispatcher_rpc_js_1.fillAccountsFromTransactionDataRpc)(ev, msg, meta, programInvokes, resolver);
+        (0, common_filler_rpc_js_1.fillDataRpc)(ev, msg, meta, programInvokes);
+    }
+}
+function setRecentBlockhash(events, recentBlockhash) {
+    if (!recentBlockhash)
+        return;
+    for (const ev of events) {
+        const data = eventPayload(ev);
+        if (data?.metadata)
+            data.metadata.recent_blockhash = recentBlockhash;
+    }
+}
+/**
+ * 与 Rust gRPC `parse_logs` 中 `fill_accounts_from_transaction_data` + `fill_data` 对齐：
+ * 对已由日志解析出的 `DexEvent` 用交易 message + meta 补全账户等字段。
+ */
+function applyAccountFillsToLogEvents(events, msg, meta) {
+    applyRpcFills(events, msg, meta);
+    (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(events);
+}
+/**
+ * 解析已获取的 `VersionedTransactionResponse`（顺序：指令 → 日志 → 账户/数据填充）。
+ */
+function parseRpcTransaction(tx, signature, filter, options) {
+    const msg = tx.transaction?.message;
+    if (!msg || !(0, rpc_invoke_map_js_1.isCompiledVersionedMessage)(msg)) {
+        return {
+            ok: false,
+            error: {
+                kind: "ConversionError",
+                message: "交易 message 非编译形态（例如使用了 jsonParsed）。请使用默认/非 parsed 的 getTransaction 响应。",
+            },
+        };
+    }
+    const meta = tx.meta ?? null;
+    const slot = tx.slot;
+    const blockTimeUs = options?.blockTimeUs ?? (tx.blockTime != null ? tx.blockTime * 1_000_000 : undefined);
+    const grpcRecvUs = options?.grpcRecvUs ?? Math.floor(Date.now() * 1000);
+    const txIndex = options?.txIndex ?? 0;
+    const rb = recentBlockhashBytes(msg.recentBlockhash);
+    const hasPumpfunCreateLog = detectPumpfunCreateInLogs(meta?.logMessages ?? [], signature, slot, txIndex, blockTimeUs, grpcRecvUs, rb);
+    const instructionEvents = parseOuterAndInnerInstructions(msg, meta, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, hasPumpfunCreateLog);
+    setRecentBlockhash(instructionEvents, msg.recentBlockhash);
+    const logEvents = [];
+    const activeProgramStack = [];
+    for (const log of meta?.logMessages ?? []) {
+        const invoke = (0, optimized_matcher_js_1.parseInvokeInfo)(log);
+        if (invoke) {
+            activeProgramStack.length = Math.max(0, invoke.depth - 1);
+            activeProgramStack.push(invoke.programId);
+        }
+        const e = (0, optimized_matcher_js_1.parseLogOptimizedWithProgramId)(log, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, hasPumpfunCreateLog, rb, activeProgramStack[activeProgramStack.length - 1]);
+        if (e) {
+            logEvents.push(e);
+        }
+        const completed = (0, optimized_matcher_js_1.parseProgramCompleteInfo)(log);
+        if (completed) {
+            const idx = activeProgramStack.lastIndexOf(completed);
+            if (idx >= 0)
+                activeProgramStack.length = idx;
+        }
+    }
+    applyRpcFills(instructionEvents, msg, meta);
+    applyRpcFills(logEvents, msg, meta);
+    const events = (0, log_instr_dedup_js_1.dedupeLogInstructionEvents)(logEvents, instructionEvents);
+    (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(events);
+    return {
+        ok: true,
+        events: filter ? events.map((event) => (0, types_js_1.eventTypeFilterNormalizeDexEvent)(filter, event)) : events,
+    };
+}
+var account_dispatcher_rpc_js_2 = require("./core/account_dispatcher_rpc.js");
+Object.defineProperty(exports, "fillAccountsFromTransactionDataRpc", { enumerable: true, get: function () { return account_dispatcher_rpc_js_2.fillAccountsFromTransactionDataRpc; } });
+var common_filler_rpc_js_2 = require("./core/common_filler_rpc.js");
+Object.defineProperty(exports, "fillDataRpc", { enumerable: true, get: function () { return common_filler_rpc_js_2.fillDataRpc; } });

package/dist/shredstream/alt_lookup.d.ts

@@ -0,0 +1,9 @@
+/**
+ * V0 交易：从链上拉取 ALT 账户，拼出与运行时一致的完整账户 key 列表（静态 + 查找表展开）。
+ */
+import { AddressLookupTableAccount, Connection } from "@solana/web3.js";
+import type { ShredWasmTx } from "./instruction_parse.js";
+/** 批量拉取 ALT，供同一 Entry 内多笔交易复用 */
+export declare function loadAddressLookupTableAccounts(connection: Connection, lookupTableAddresses: readonly string[]): Promise<Map<string, AddressLookupTableAccount>>;
+/** 使用已拉取的 ALT 构造完整账户表（base58）；失败时退回仅静态表 */
+export declare function fullAccountKeyStringsFromShredTx(tx: ShredWasmTx, altByAddress: Map<string, AddressLookupTableAccount>): string[];

package/dist/shredstream/alt_lookup.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAddressLookupTableAccounts = loadAddressLookupTableAccounts;
+exports.fullAccountKeyStringsFromShredTx = fullAccountKeyStringsFromShredTx;
+/**
+ * V0 交易：从链上拉取 ALT 账户，拼出与运行时一致的完整账户 key 列表（静态 + 查找表展开）。
+ */
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+/** 批量拉取 ALT，供同一 Entry 内多笔交易复用 */
+async function loadAddressLookupTableAccounts(connection, lookupTableAddresses) {
+    const map = new Map();
+    if (lookupTableAddresses.length === 0)
+        return map;
+    const pks = lookupTableAddresses.map((s) => new web3_js_1.PublicKey(s));
+    const infos = await connection.getMultipleAccountsInfo(pks);
+    for (let i = 0; i < pks.length; i++) {
+        const info = infos[i];
+        if (!info?.data)
+            continue;
+        const state = web3_js_1.AddressLookupTableAccount.deserialize(info.data);
+        const alt = new web3_js_1.AddressLookupTableAccount({ key: pks[i], state });
+        map.set(pks[i].toBase58(), alt);
+    }
+    return map;
+}
+/** 使用已拉取的 ALT 构造完整账户表（base58）；失败时退回仅静态表 */
+function fullAccountKeyStringsFromShredTx(tx, altByAddress) {
+    if (tx.messageVersion !== "v0" || !tx.addressTableLookups?.length) {
+        return tx.accounts;
+    }
+    const lookups = tx.addressTableLookups;
+    const altAccounts = [];
+    for (const l of lookups) {
+        const alt = altByAddress.get(l.accountKey);
+        if (!alt) {
+            return tx.accounts;
+        }
+        altAccounts.push(alt);
+    }
+    const header = tx.header;
+    const rb = tx.recentBlockhash;
+    if (!header || !rb || rb.length !== 32) {
+        return tx.accounts;
+    }
+    const msg = new web3_js_1.MessageV0({
+        header,
+        staticAccountKeys: tx.accounts.map((s) => new web3_js_1.PublicKey(s)),
+        recentBlockhash: bs58_1.default.encode(rb),
+        compiledInstructions: (tx.instructions ?? []).map((ix) => ({
+            programIdIndex: ix.programIdIndex,
+            accountKeyIndexes: Array.from(ix.accounts),
+            data: Buffer.from(ix.data),
+        })),
+        addressTableLookups: lookups.map((l) => ({
+            accountKey: new web3_js_1.PublicKey(l.accountKey),
+            writableIndexes: Array.from(l.writableIndexes),
+            readonlyIndexes: Array.from(l.readonlyIndexes),
+        })),
+    });
+    const keys = msg.getAccountKeys({ addressLookupTableAccounts: altAccounts });
+    const out = [];
+    for (let i = 0; i < keys.length; i++) {
+        out.push(keys.get(i).toBase58());
+    }
+    return out;
+}

package/dist/shredstream/client.d.ts

@@ -0,0 +1,65 @@
+import { type DexEvent } from "../core/dex_event.js";
+import type { EventTypeFilter } from "../grpc/types.js";
+import { type ShredStreamConfig } from "./config.js";
+/** 订阅周期内累计（用于排查「无 gRPC 包 / 解码失败 / 无 DEX 事件」） */
+export type ShredStreamReceiveStats = {
+    entryMessagesReceived: number;
+    entryDecodeFailures: number;
+    transactionsDecoded: number;
+    dexEventsQueued: number;
+};
+/** 有界 FIFO 队列（容量与 Rust `ArrayQueue::new(100_000)` 一致；`clone()` 共享底层缓冲，同 `Arc<ArrayQueue>`） */
+export declare class ShredEventQueue {
+    private static readonly CAP;
+    private readonly buf;
+    constructor(sharedBuf?: DexEvent[]);
+    /** 当前元素个数（与 Rust `ArrayQueue::len` 一致） */
+    len(): number;
+    /** 最大容量 */
+    capacity(): number;
+    push(e: DexEvent): boolean;
+    pop(): DexEvent | undefined;
+    clone(): ShredEventQueue;
+}
+export declare class ShredStreamClient {
+    private readonly endpoint;
+    private readonly config;
+    private readonly ServiceClient;
+    private loopAbort;
+    private loopPromise;
+    private activeCall;
+    private receiveStats;
+    private constructor();
+    static connect(endpoint: string): Promise<ShredStreamClient>;
+    /** 与 Rust `ShredStreamClient::new` 一致 */
+    static new(endpoint: string): Promise<ShredStreamClient>;
+    static connectWithConfig(endpoint: string, config: ShredStreamConfig): Promise<ShredStreamClient>;
+    /** 与 Rust `ShredStreamClient::new_with_config` 一致 */
+    static newWithConfig(endpoint: string, config: ShredStreamConfig): Promise<ShredStreamClient>;
+    /** 与 Rust `#[derive(Clone)]` 一致：多句柄共享同一连接状态（TS 中为同一对象引用） */
+    clone(): ShredStreamClient;
+    /** 当前订阅周期内 gRPC Entry 条数、解码失败次数、解码出的交易数、入队 DexEvent 数 */
+    getReceiveStats(): Readonly<ShredStreamReceiveStats>;
+    /**
+     * 与 Rust `new_with_config` 中 `ShredstreamProxyClient::connect_with_config(endpoint, &config)` 一致：
+     * `connection_timeout_ms` / `request_timeout_ms` / `max_decoding_message_size` 见 `shredstream/proto/mod.rs`。
+     */
+    private pingConnection;
+    /**
+     * 订阅 DEX 事件（自动重连）；返回队列供轮询消费（与 Rust `subscribe` 一致）。
+     * 重连循环使用订阅时刻的配置快照（与 Rust 在 `tokio::spawn` 前 `config.clone()` 一致）。
+     */
+    subscribe(eventTypeFilter?: EventTypeFilter): Promise<ShredEventQueue>;
+    /** 与 Rust `subscribe_with_filter` 对齐：在解析热路径按事件类型预过滤。 */
+    subscribeWithFilter(eventTypeFilter?: EventTypeFilter): Promise<ShredEventQueue>;
+    /** 停止订阅并中止当前流 */
+    stop(): Promise<void>;
+    private runReconnectLoop;
+    /** 与 Rust `stream_events` + `connect_with_config`（tonic Endpoint / Grpc 消息上限）一致 */
+    private streamOnce;
+    private processEntryMessage;
+    /** 无 RPC：仅用静态账户表 */
+    private processEntryMessageSync;
+    /** 拉取 ALT 后完整账户表解析 */
+    private processEntryMessageWithAlt;
+}