sol-parser-sdk 0.5.9 → 0.5.11

package/dist/grpc/client.js

@@ -45,51 +45,18 @@ 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 async_event_queue_js_1 = require("./async_event_queue.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;
-    }
+function cancelSubscribeStream(stream) {
+    if (!stream)
+        return;
+    // grpc-js emits CANCELLED through `error`; guard the short setup window before
+    // the normal lifecycle listeners have been installed.
+    stream.once("error", () => { });
+    stream.cancel();
 }
 /** Yellowstone gRPC 客户端包装器 */
 class YellowstoneGrpc {
@@ -105,6 +72,9 @@ class YellowstoneGrpc {
             ...gc,
             keepAliveIntervalMs: config.keep_alive_interval_ms,
             keepAliveTimeoutMs: config.keep_alive_timeout_ms,
+            initialReconnectBackoffMs: config.retry_delay_ms,
+            maxReconnectBackoffMs: 60_000,
+            flowControlWindowBytes: config.flow_control_window_bytes,
         }));
     }
     /** 连接到 gRPC 服务器 */
@@ -302,6 +272,22 @@ class YellowstoneGrpc {
         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);
     }
+    parseAccountEventRaw(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) : "", YellowstoneGrpc.protobufNumber(update.slot), 0, blockTimeUs, grpcRecvUs);
+        return (0, mod_js_1.parseAccountUnified)(account, metadata, eventTypeFilter);
+    }
     initialSubscribeRequest(filter) {
         return {
             transactions: {
@@ -332,7 +318,7 @@ class YellowstoneGrpc {
         const streamHolder = { current: null };
         const cancel = () => {
             isCancelled = true;
-            streamHolder.current?.end();
+            cancelSubscribeStream(streamHolder.current);
             streamHolder.current = null;
         };
         this.subscribers.set(id, { filter, callbacks, cancel });
@@ -344,6 +330,10 @@ class YellowstoneGrpc {
                 while (!isCancelled) {
                     try {
                         const stream = await this.client.subscribe();
+                        if (isCancelled) {
+                            cancelSubscribeStream(stream);
+                            break;
+                        }
                         streamHolder.current = stream;
                         await new Promise((resolve, reject) => {
                             stream.write(this.initialSubscribeRequest(filter), (err) => {
@@ -353,7 +343,6 @@ class YellowstoneGrpc {
                                     resolve();
                             });
                         });
-                        backoffMs = this.config.retry_delay_ms;
                         await new Promise((resolve, reject) => {
                             const cleanup = () => {
                                 stream.removeAllListeners();
@@ -364,6 +353,7 @@ class YellowstoneGrpc {
                             stream.on("data", (update) => {
                                 if (isCancelled)
                                     return;
+                                backoffMs = this.config.retry_delay_ms;
                                 if (update.ping) {
                                     stream.write(this.subscribePingPongRequest(), (werr) => {
                                         if (werr && callbacks.onError && !isCancelled) {
@@ -396,6 +386,8 @@ class YellowstoneGrpc {
                     catch (err) {
                         if (isCancelled)
                             break;
+                        cancelSubscribeStream(streamHolder.current);
+                        streamHolder.current = null;
                         const e = err instanceof Error ? err : new Error(String(err));
                         callbacks.onError?.(e);
                         if (!autoReconnect)
@@ -415,7 +407,7 @@ class YellowstoneGrpc {
                 }
             }
             finally {
-                streamHolder.current?.end();
+                cancelSubscribeStream(streamHolder.current);
                 streamHolder.current = null;
                 this.subscribers.delete(id);
             }
@@ -432,15 +424,26 @@ class YellowstoneGrpc {
      * 订阅并直接产出 `DexEvent`。
      *
      * 交易更新走统一交易解析（外层/内层指令 + 日志 + 数据填充）；账户更新走 `parseAccountUnified`。
-     * 事件队列满时丢弃新事件，避免回调阻塞 gRPC 读循环，保持低延迟。
+     * 事件队列满时按配置丢弃事件，避免回调阻塞 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 events = new async_event_queue_js_1.AsyncEventQueue(Math.max(1, this.config.buffer_size), 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);
-        const emitEvent = (event) => events.push(event);
+        let nextDropWarningAt = 0;
+        const reportError = (error) => errors.push(error);
+        const emitEvent = (event) => {
+            if (events.push(event))
+                return;
+            const now = Date.now();
+            if (now < nextDropWarningAt)
+                return;
+            nextDropWarningAt = now + 10_000;
+            reportError(new Error(`Dex event queue full; dropped=${events.dropped()} buffer_size=${this.config.buffer_size} ` +
+                `strategy=${options?.queueOverflowStrategy ?? "drop-newest"}`));
+        };
         let flushTimer;
         if (order.needsTimer) {
             const intervalMs = this.config.order_mode === "MicroBatch"
@@ -452,9 +455,27 @@ class YellowstoneGrpc {
         let currentTransactionFilters = transactionFilters;
         let currentAccountFilters = accountFilters;
         const streamHolder = { current: null };
+        let cancelReconnectDelay;
+        const waitBeforeReconnect = (delayMs) => new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (cancelReconnectDelay === finish)
+                    cancelReconnectDelay = undefined;
+                resolve();
+            };
+            const timer = setTimeout(finish, delayMs);
+            cancelReconnectDelay = finish;
+            if (isCancelled)
+                finish();
+        });
         const cancel = () => {
             isCancelled = true;
-            streamHolder.current?.end();
+            cancelReconnectDelay?.();
+            cancelSubscribeStream(streamHolder.current);
             streamHolder.current = null;
             if (flushTimer)
                 clearInterval(flushTimer);
@@ -485,6 +506,10 @@ class YellowstoneGrpc {
                 while (!isCancelled) {
                     try {
                         const stream = await this.client.subscribe();
+                        if (isCancelled) {
+                            cancelSubscribeStream(stream);
+                            break;
+                        }
                         streamHolder.current = stream;
                         await new Promise((resolve, reject) => {
                             stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
@@ -494,7 +519,6 @@ class YellowstoneGrpc {
                                     resolve();
                             });
                         });
-                        backoffMs = this.config.retry_delay_ms;
                         await new Promise((resolve, reject) => {
                             const cleanup = () => {
                                 stream.removeAllListeners();
@@ -505,33 +529,44 @@ class YellowstoneGrpc {
                             stream.on("data", (update) => {
                                 if (isCancelled)
                                     return;
-                                order.flushDue(emitEvent);
+                                backoffMs = this.config.retry_delay_ms;
+                                if (order.needsTimer)
+                                    order.flushDue(emitEvent);
                                 if (update.ping) {
                                     stream.write(this.subscribePingPongRequest(), (werr) => {
                                         if (werr && !isCancelled) {
-                                            errors.push(werr instanceof Error ? werr : new Error(String(werr)));
+                                            reportError(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;
+                                    const blockTimeUs = YellowstoneGrpc.timestampToMicros(update.createdAt ?? update.created_at);
+                                    const txUpdate = update.transaction;
+                                    const tx = txUpdate?.transaction;
                                     if (tx) {
-                                        const fallbackSlot = YellowstoneGrpc.protobufNumber(converted.transaction?.slot ?? 0);
+                                        const slot = txUpdate?.slot ?? 0n;
+                                        const fallbackSlot = YellowstoneGrpc.protobufNumber(slot);
                                         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 });
+                                        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 (converted.account) {
-                                        const ev = this.parseAccountEvent(converted.account, grpcRecvUs, eventTypeFilter, converted.createdAtUs);
+                                    if (update.account) {
+                                        const ev = this.parseAccountEventRaw(update.account, grpcRecvUs, eventTypeFilter, blockTimeUs);
                                         if (ev)
                                             emitEvent(ev);
                                     }
                                 }
                                 catch (err) {
-                                    errors.push(err instanceof Error ? err : new Error(String(err)));
+                                    reportError(err instanceof Error ? err : new Error(String(err)));
                                 }
                             });
                             stream.on("error", (err) => {
@@ -547,25 +582,28 @@ class YellowstoneGrpc {
                     catch (err) {
                         if (isCancelled)
                             break;
-                        errors.push(err instanceof Error ? err : new Error(String(err)));
+                        cancelSubscribeStream(streamHolder.current);
+                        streamHolder.current = null;
+                        reportError(err instanceof Error ? err : new Error(String(err)));
                         if (!autoReconnect)
                             break;
-                        await new Promise((r) => setTimeout(r, backoffMs));
+                        await waitBeforeReconnect(backoffMs);
                         backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
                         continue;
                     }
                     if (isCancelled || !autoReconnect)
                         break;
-                    await new Promise((r) => setTimeout(r, backoffMs));
+                    await waitBeforeReconnect(backoffMs);
                     backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
                 }
             }
             finally {
-                streamHolder.current?.end();
+                cancelSubscribeStream(streamHolder.current);
                 streamHolder.current = null;
                 if (flushTimer)
                     clearInterval(flushTimer);
-                order.flushAll(emitEvent);
+                if (!isCancelled)
+                    order.flushAll(emitEvent);
                 events.close();
                 errors.close();
                 this.dexSubscribers.delete(id);

package/dist/grpc/geyser_connect.d.ts

@@ -18,8 +18,14 @@ export interface GeyserConnectConfig {
     keepAliveIntervalMs?: number;
     /** gRPC keepalive 应答超时（毫秒） */
     keepAliveTimeoutMs?: number;
+    /** gRPC 连接初始重试退避（毫秒） */
+    initialReconnectBackoffMs?: number;
+    /** gRPC 连接最大重试退避（毫秒） */
+    maxReconnectBackoffMs?: number;
+    /** HTTP/2 本地接收窗口（字节） */
+    flowControlWindowBytes?: number;
 }
-/** 与 Rust `GeyserConnectConfig::default` 一致 */
+/** 公共字段与 Rust `GeyserConnectConfig::default` 一致，并包含 Node gRPC 通道默认值。 */
 export declare function defaultGeyserConnectConfig(): GeyserConnectConfig;
 /** 与 `ClientConfig` / `grpc.keepalive_*` 对齐，用于长连接抗 NAT/负载均衡 idle 断开 */
 export declare function geyserGrpcChannelOptions(config?: GeyserConnectConfig): ChannelOptions;

package/dist/grpc/geyser_connect.js

@@ -7,7 +7,7 @@ exports.defaultGeyserConnectConfig = defaultGeyserConnectConfig;
 exports.geyserGrpcChannelOptions = geyserGrpcChannelOptions;
 exports.connectYellowstoneGeyser = connectYellowstoneGeyser;
 const yellowstone_grpc_1 = __importDefault(require("@triton-one/yellowstone-grpc"));
-/** 与 Rust `GeyserConnectConfig::default` 一致 */
+/** 公共字段与 Rust `GeyserConnectConfig::default` 一致，并包含 Node gRPC 通道默认值。 */
 function defaultGeyserConnectConfig() {
     return {
         connectTimeoutMs: 8000,
@@ -15,6 +15,9 @@ function defaultGeyserConnectConfig() {
         xToken: undefined,
         keepAliveIntervalMs: 30_000,
         keepAliveTimeoutMs: 5000,
+        initialReconnectBackoffMs: 1000,
+        maxReconnectBackoffMs: 60_000,
+        flowControlWindowBytes: 1024 * 1024,
     };
 }
 /** 与 `ClientConfig` / `grpc.keepalive_*` 对齐，用于长连接抗 NAT/负载均衡 idle 断开 */
@@ -29,6 +32,9 @@ function geyserGrpcChannelOptions(config = defaultGeyserConnectConfig()) {
         "grpc.keepalive_timeout_ms": timeout,
         /** 无活跃 RPC 时仍发 keepalive，避免长时间仅订阅时被中间设备掐断 */
         "grpc.keepalive_permit_without_calls": 1,
+        "grpc.initial_reconnect_backoff_ms": config.initialReconnectBackoffMs,
+        "grpc.max_reconnect_backoff_ms": config.maxReconnectBackoffMs,
+        "grpc-node.flow_control_window": config.flowControlWindowBytes,
     };
 }
 /**

package/dist/grpc/log_instr_dedup.js

@@ -62,7 +62,7 @@ function nextOccurrence(base, counts) {
     counts.set(base, current + 1);
     return current;
 }
-function dedupeKey(ev, pumpfunLaneCounts) {
+function dedupeKey(ev, occurrenceCounts) {
     const name = eventName(ev);
     const data = payload(ev);
     if (!data)
@@ -70,7 +70,7 @@ function dedupeKey(ev, pumpfunLaneCounts) {
     if (PUMPFUN_TRADE_NAMES.has(name)) {
         const lane = ixLane(data.ix_name);
         const base = `${data.mint}|${data.user}|${Boolean(data.is_buy)}|${lane}`;
-        const occurrence = nextOccurrence(base, pumpfunLaneCounts);
+        const occurrence = nextOccurrence(`PumpFun|${base}`, occurrenceCounts);
         return `PumpFunTrade|${base}|${occurrence}`;
     }
     switch (name) {
@@ -98,12 +98,28 @@ function dedupeKey(ev, pumpfunLaneCounts) {
             return `PumpSwapLiquidityAdded|${data.pool}|${data.user}`;
         case "PumpSwapLiquidityRemoved":
             return `PumpSwapLiquidityRemoved|${data.pool}|${data.user}`;
-        case "RaydiumClmmSwap":
-            return `RaydiumClmmSwap|${data.pool_state}|${Boolean(data.zero_for_one)}`;
-        case "RaydiumAmmV4Swap":
-            return `RaydiumAmmV4Swap|${data.amm}`;
-        case "MeteoraDlmmSwap":
-            return `MeteoraDlmmSwap|${data.pool}|${data.from}|${Boolean(data.swap_for_y)}`;
+        case "RaydiumClmmSwap": {
+            const base = String(data.pool_state);
+            return `RaydiumClmmSwap|${base}|${nextOccurrence(`RaydiumClmm|${base}`, occurrenceCounts)}`;
+        }
+        case "RaydiumCpmmSwap": {
+            const base = String(data.pool_id);
+            return `RaydiumCpmmSwap|${base}|${nextOccurrence(`RaydiumCpmm|${base}`, occurrenceCounts)}`;
+        }
+        case "RaydiumAmmV4Swap": {
+            const base = data.max_amount_in !== 0n && data.max_amount_in !== 0
+                ? `out|${data.amount_out}`
+                : `in|${data.amount_in}`;
+            return `RaydiumAmmV4Swap|${base}|${nextOccurrence(`RaydiumAmmV4|${base}`, occurrenceCounts)}`;
+        }
+        case "OrcaWhirlpoolSwap": {
+            const base = String(data.whirlpool);
+            return `OrcaWhirlpoolSwap|${base}|${nextOccurrence(`OrcaWhirlpool|${base}`, occurrenceCounts)}`;
+        }
+        case "MeteoraDlmmSwap": {
+            const base = `${data.pool}|${data.from}|${Boolean(data.swap_for_y)}`;
+            return `MeteoraDlmmSwap|${base}|${nextOccurrence(`MeteoraDlmm|${base}`, occurrenceCounts)}`;
+        }
         default:
             return null;
     }
@@ -282,6 +298,8 @@ function mergeRaydiumAmmV4Swap(log, ix) {
         "serum_vault_signer",
         "user_source_token_account",
         "user_destination_token_account",
+        "user_source_owner",
+        "amm",
     ]) {
         fillString(log, key, ix);
     }
@@ -376,16 +394,16 @@ function mergeGrpcInstructionIntoLog(logEvent, ixEvent) {
 function dedupeLogInstructionEvents(logEvents, instructionEvents) {
     const out = [];
     const indexByKey = new Map();
-    const logPumpfunLaneCounts = new Map();
-    const ixPumpfunLaneCounts = new Map();
+    const logOccurrenceCounts = new Map();
+    const ixOccurrenceCounts = new Map();
     for (const ev of logEvents) {
-        const key = dedupeKey(ev, logPumpfunLaneCounts);
+        const key = dedupeKey(ev, logOccurrenceCounts);
         if (key)
             indexByKey.set(key, out.length);
         out.push(ev);
     }
     for (const ev of instructionEvents) {
-        const key = dedupeKey(ev, ixPumpfunLaneCounts);
+        const key = dedupeKey(ev, ixOccurrenceCounts);
         if (!key) {
             out.push(ev);
             continue;

package/dist/grpc/types.d.ts

@@ -98,16 +98,18 @@ export interface ClientConfig {
     keep_alive_interval_ms: number;
     keep_alive_timeout_ms: number;
     buffer_size: number;
+    /** Node gRPC HTTP/2 receive window. Larger values reduce stalls on bursty streams. */
+    flow_control_window_bytes?: number;
     order_mode: OrderMode;
     order_timeout_ms: number;
     micro_batch_us: number;
 }
-/** 与 Rust `grpc::config` 中 `StreamingConfig` 别名（即 `ClientConfig`）一致 */
+/** 与 Rust `grpc::config` 中 `StreamingConfig` 别名一致，并包含可选 Node gRPC 参数。 */
 export type StreamingConfig = ClientConfig;
 export declare function defaultClientConfig(): ClientConfig;
-/** 与 Rust `ClientConfig::low_latency` 一致 */
+/** Rust `ClientConfig::low_latency` 的 Node 调优版本，使用更小的 JS 对象队列。 */
 export declare function lowLatencyClientConfig(): ClientConfig;
-/** 与 Rust `ClientConfig::high_throughput` 一致 */
+/** Rust `ClientConfig::high_throughput` 的 Node 调优版本，使用更小的 JS 对象队列。 */
 export declare function highThroughputClientConfig(): ClientConfig;
 export interface TransactionFilter {
     account_include: string[];

package/dist/grpc/types.js

@@ -42,12 +42,13 @@ function defaultClientConfig() {
         keep_alive_interval_ms: 30000,
         keep_alive_timeout_ms: 5000,
         buffer_size: 8192,
+        flow_control_window_bytes: 1024 * 1024,
         order_mode: "Unordered",
         order_timeout_ms: 100,
         micro_batch_us: 100,
     };
 }
-/** 与 Rust `ClientConfig::low_latency` 一致 */
+/** Rust `ClientConfig::low_latency` 的 Node 调优版本，使用更小的 JS 对象队列。 */
 function lowLatencyClientConfig() {
     return {
         enable_metrics: false,
@@ -60,12 +61,13 @@ function lowLatencyClientConfig() {
         keep_alive_interval_ms: 10_000,
         keep_alive_timeout_ms: 2000,
         buffer_size: 16384,
+        flow_control_window_bytes: 16 * 1024 * 1024,
         order_mode: "Unordered",
         order_timeout_ms: 50,
         micro_batch_us: 50,
     };
 }
-/** 与 Rust `ClientConfig::high_throughput` 一致 */
+/** Rust `ClientConfig::high_throughput` 的 Node 调优版本，使用更小的 JS 对象队列。 */
 function highThroughputClientConfig() {
     return {
         enable_metrics: true,
@@ -78,6 +80,7 @@ function highThroughputClientConfig() {
         keep_alive_interval_ms: 60_000,
         keep_alive_timeout_ms: 10_000,
         buffer_size: 32768,
+        flow_control_window_bytes: 16 * 1024 * 1024,
         order_mode: "Unordered",
         order_timeout_ms: 200,
         micro_batch_us: 200,

package/dist/index.d.ts

@@ -41,7 +41,7 @@ export { parseInstructionUnified, parsePumpfunInstruction, parsePumpswapInstruct
 /** Rust `instr` 根模块蛇形命名别名 */
 export { parse_instruction_unified, parse_pumpfun_instruction, parse_pumpswap_instruction, parse_meteora_damm_instruction, parse_meteora_dlmm_instruction, parse_meteora_pools_instruction, parse_pump_fees_instruction, } from "./instr/rust_aliases.js";
 export * as programIds from "./instr/program_ids.js";
-export { YellowstoneGrpc, type SubscribeCallbacks, type DexEventSubscription } from "./grpc/client.js";
+export { YellowstoneGrpc, type SubscribeCallbacks, type DexEventSubscription, type SubscribeDexEventsOptions, type EventQueueOverflowStrategy, } from "./grpc/client.js";
 export { connectYellowstoneGeyser, defaultGeyserConnectConfig, geyserGrpcChannelOptions, type GeyserConnectConfig, } from "./grpc/geyser_connect.js";
 /** 与 Rust `sol_parser_sdk::grpc::event_parser` 模块对应 */
 export * as event_parser from "./grpc/event_parser.js";

package/dist/instr/inner.js

@@ -48,7 +48,7 @@ function filterDexEvent(ev, filter) {
         ? (0, types_js_1.eventTypeFilterNormalizeDexEvent)(filter, ev)
         : null;
 }
-function pumpFeesEventDisc(disc) {
+function eventCpiDiscriminator(disc) {
     if (bytesEq(disc, 0, EVENT_CPI_PREFIX))
         return (0, binary_js_1.readU64LE)(disc, 8);
     if (bytesEq(disc, 8, EVENT_CPI_SUFFIX))
@@ -116,14 +116,16 @@ const LOG = {
     METEORA_DAMM_INITIALIZE_POOL: [228, 50, 246, 85, 203, 66, 134, 37],
     METEORA_DAMM_CREATE_POSITION: [156, 15, 119, 198, 29, 181, 221, 55],
     METEORA_DAMM_CLOSE_POSITION: [20, 145, 144, 68, 143, 142, 214, 178],
-    METEORA_DLMM_SWAP: [143, 190, 90, 218, 196, 30, 51, 222],
-    METEORA_DLMM_ADD_LIQUIDITY: [181, 157, 89, 67, 143, 182, 52, 72],
-    METEORA_DLMM_REMOVE_LIQUIDITY: [80, 85, 209, 72, 24, 206, 35, 178],
-    METEORA_DLMM_INITIALIZE_POOL: [95, 180, 10, 172, 84, 174, 232, 40],
+    METEORA_DLMM_SWAP: [81, 108, 227, 190, 205, 208, 10, 196],
+    METEORA_DLMM_SWAP2: [46, 116, 82, 215, 148, 27, 84, 77],
+    METEORA_DLMM_ADD_LIQUIDITY: [31, 94, 125, 90, 227, 52, 61, 186],
+    METEORA_DLMM_REMOVE_LIQUIDITY: [116, 244, 97, 232, 103, 31, 152, 58],
+    METEORA_DLMM_INITIALIZE_POOL: [185, 74, 252, 125, 27, 215, 188, 111],
     METEORA_DLMM_INITIALIZE_BIN_ARRAY: [11, 18, 155, 194, 33, 115, 238, 119],
-    METEORA_DLMM_CREATE_POSITION: [123, 233, 11, 43, 146, 180, 97, 119],
-    METEORA_DLMM_CLOSE_POSITION: [94, 168, 102, 45, 59, 122, 137, 54],
-    METEORA_DLMM_CLAIM_FEE: [152, 70, 208, 111, 104, 91, 44, 1],
+    METEORA_DLMM_CREATE_POSITION: [144, 142, 252, 84, 157, 53, 37, 121],
+    METEORA_DLMM_CLOSE_POSITION: [255, 196, 16, 107, 28, 202, 53, 128],
+    METEORA_DLMM_CLAIM_FEE: [75, 122, 154, 48, 140, 74, 123, 163],
+    METEORA_DLMM_CLAIM_FEE2: [232, 171, 242, 97, 58, 77, 35, 45],
     RAYDIUM_LAUNCHLAB_POOL_CREATE: [151, 215, 226, 9, 118, 161, 115, 174],
     RAYDIUM_LAUNCHLAB_TRADE: [189, 219, 127, 211, 78, 230, 97, 238],
 };
@@ -200,6 +202,28 @@ const IX = {
         [80, 85, 209, 72, 24, 206, 177, 108],
         [95, 180, 10, 172, 84, 174, 232, 40],
     ],
+    METEORA_DLMM: [
+        [181, 157, 89, 67, 143, 182, 52, 72],
+        [228, 162, 78, 28, 70, 219, 116, 115],
+        [169, 32, 79, 137, 136, 232, 70, 137],
+        [112, 191, 101, 171, 28, 144, 127, 187],
+        [123, 134, 81, 0, 49, 68, 98, 98],
+        [174, 90, 35, 115, 186, 40, 147, 226],
+        [35, 86, 19, 185, 78, 212, 75, 211],
+        [45, 154, 237, 210, 221, 15, 166, 92],
+        [73, 59, 36, 120, 237, 83, 108, 198],
+        [219, 192, 234, 71, 190, 191, 102, 80],
+        [143, 19, 242, 145, 213, 15, 104, 115],
+        [46, 82, 125, 146, 85, 141, 228, 153],
+        [80, 85, 209, 72, 24, 206, 177, 108],
+        [230, 215, 82, 127, 241, 101, 227, 146],
+        [248, 198, 158, 145, 225, 117, 135, 200],
+        [65, 75, 63, 76, 235, 91, 91, 136],
+        [250, 73, 101, 33, 38, 207, 75, 184],
+        [43, 215, 247, 132, 137, 60, 243, 81],
+        [56, 173, 230, 208, 173, 228, 156, 205],
+        [74, 98, 192, 214, 177, 51, 75, 51],
+    ],
 };
 function firstByteIn(data, allowed) {
     return data.length > 0 && allowed.includes(data[0]);
@@ -213,7 +237,7 @@ function normalInstructionDataMayParse(programId, data) {
     if (programId === program_ids_js_1.RAYDIUM_AMM_V4_PROGRAM_ID)
         return firstByteIn(data, [1, 3, 4, 7, 9, 11]);
     if (programId === program_ids_js_1.METEORA_DLMM_PROGRAM_ID)
-        return firstByteIn(data, [0, 1, 2, 7, 8, 11, 13, 14]);
+        return headIn(data, IX.METEORA_DLMM);
     if (programId === program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID) {
         return discEq(data, LOG.METEORA_DAMM_INITIALIZE_POOL);
     }
@@ -243,7 +267,7 @@ function parseInnerCompiledInstructionIfSupported(data, accounts, signature, slo
     return (0, mod_js_1.parseInstructionUnified)(data, accounts, signature, slot, txIndex, blockTimeUs, grpcRecvUs, filter, programId);
 }
 function parsePumpFeesInner(disc, data, metadata) {
-    const eventDisc = pumpFeesEventDisc(disc);
+    const eventDisc = eventCpiDiscriminator(disc);
     if (eventDisc === null)
         return null;
     if (eventDisc === disc8(LOG.PUMP_FEES_CREATE_FEE_SHARING_CONFIG)) {
@@ -431,12 +455,10 @@ function parseInnerInstructionUnified(instructionData, accounts, signature, slot
     else if (programId === program_ids_js_1.METEORA_DLMM_PROGRAM_ID) {
         if (filter && !(0, types_js_1.eventTypeFilterIncludesMeteoraDlmm)(filter))
             return null;
-        if (!discTailEq(disc, EVENT_CPI_SUFFIX))
+        const eventDisc = eventCpiDiscriminator(disc);
+        if (eventDisc === null)
             return null;
-        const decoded = new Uint8Array(8 + data.length);
-        decoded.set(disc.subarray(0, 8), 0);
-        decoded.set(data, 8);
-        ev = (0, meteora_dlmm_js_1.parseDlmmFromDecoded)(decoded, metadata);
+        ev = (0, meteora_dlmm_js_1.parseDlmmEventFromData)(eventDisc, data, metadata);
     }
     else if (programId === program_ids_js_1.RAYDIUM_LAUNCHLAB_PROGRAM_ID) {
         if (filter && !(0, types_js_1.eventTypeFilterIncludesRaydiumLaunchlab)(filter))