sol-parser-sdk-nodejs 0.4.4 → 0.5.5

package/dist/logs/pump.js

@@ -18,12 +18,58 @@ const DISC_CREATE = disc([27, 114, 169, 77, 222, 235, 99, 118]);
 const DISC_TRADE = disc([189, 219, 127, 211, 78, 230, 97, 238]);
 const DISC_MIGRATE = disc([189, 233, 93, 185, 92, 148, 234, 148]);
 const DISC_MIGRATE_BONDING_CURVE_CREATOR = disc([155, 167, 104, 220, 213, 108, 243, 3]);
+function normalizePumpfunIxName(ixName) {
+    if (ixName === "buy_v2")
+        return "buy";
+    if (ixName === "sell_v2")
+        return "sell";
+    if (ixName === "buy_exact_quote_in_v2")
+        return "buy_exact_quote_in";
+    return ixName;
+}
 function bnU64(v) {
     return v ?? 0n;
 }
 function bnI64(v) {
     return v ?? 0n;
 }
+function readOptionalU64(data, offset) {
+    if (offset.value + 8 > data.length)
+        return 0n;
+    const value = bnU64((0, binary_js_1.readU64LE)(data, offset.value));
+    offset.value += 8;
+    return value;
+}
+function readOptionalPubkey(data, offset) {
+    if (offset.value + 32 > data.length)
+        return (0, dex_event_js_1.defaultPubkey)();
+    const value = (0, binary_js_1.readPubkey)(data, offset.value) ?? (0, dex_event_js_1.defaultPubkey)();
+    offset.value += 32;
+    return value;
+}
+function readTradeShareholders(data, offset) {
+    if (offset.value + 4 > data.length)
+        return [];
+    const n = (0, binary_js_1.readU32LE)(data, offset.value);
+    if (n === null || n > 64)
+        return null;
+    offset.value += 4;
+    if (offset.value + n * 34 > data.length)
+        return null;
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const address = (0, binary_js_1.readPubkey)(data, offset.value);
+        if (!address)
+            return null;
+        offset.value += 32;
+        const share_bps = (0, binary_js_1.readU16LE)(data, offset.value);
+        if (share_bps === null)
+            return null;
+        offset.value += 2;
+        out.push({ address, share_bps });
+    }
+    return out;
+}
 function parsePumpFunLogDecoded(programData, metadata) {
     const disc = (0, binary_js_1.readDiscriminatorU64)(programData);
     if (disc === null)
@@ -104,11 +150,23 @@ function parseTradeFromData(data, metadata, isCreatedBuy) {
             o = rs.next;
         }
     }
+    ix_name = normalizePumpfunIxName(ix_name);
     const mayhem_mode = (0, binary_js_1.readBool)(data, o) ?? false;
     o += 1;
     const cashback_fee_basis_points = o + 8 <= data.length ? bnU64((0, binary_js_1.readU64LE)(data, o)) : 0n;
     o += 8;
     const cashback = o + 8 <= data.length ? bnU64((0, binary_js_1.readU64LE)(data, o)) : 0n;
+    o += 8;
+    const tail = { value: o };
+    const buyback_fee_basis_points = readOptionalU64(data, tail);
+    const buyback_fee = readOptionalU64(data, tail);
+    const shareholders = readTradeShareholders(data, tail);
+    if (shareholders === null)
+        return null;
+    const quote_mint = readOptionalPubkey(data, tail);
+    const quote_amount = readOptionalU64(data, tail);
+    const virtual_quote_reserves = readOptionalU64(data, tail);
+    const real_quote_reserves = readOptionalU64(data, tail);
     const trade = {
         metadata,
         mint,
@@ -137,19 +195,28 @@ function parseTradeFromData(data, metadata, isCreatedBuy) {
         mayhem_mode,
         cashback_fee_basis_points,
         cashback,
+        buyback_fee_basis_points,
+        buyback_fee,
+        shareholders,
+        quote_mint,
+        quote_amount,
+        virtual_quote_reserves,
+        real_quote_reserves,
         is_cashback_coin: cashback_fee_basis_points > 0n,
         bonding_curve: (0, dex_event_js_1.defaultPubkey)(),
         associated_bonding_curve: (0, dex_event_js_1.defaultPubkey)(),
         token_program: (0, dex_event_js_1.defaultPubkey)(),
         creator_vault: (0, dex_event_js_1.defaultPubkey)(),
     };
-    if (ix_name === "buy" || ix_name === "buy_v2")
+    if (ix_name === "buy")
         return { PumpFunBuy: trade };
-    if (ix_name === "sell" || ix_name === "sell_v2")
+    if (ix_name === "sell")
         return { PumpFunSell: trade };
-    if (ix_name === "buy_exact_sol_in" || ix_name === "buy_exact_quote_in_v2") {
+    if (ix_name === "buy_exact_sol_in") {
         return { PumpFunBuyExactSolIn: trade };
     }
+    if (ix_name === "buy_exact_quote_in")
+        return { PumpFunBuy: trade };
     return { PumpFunTrade: trade };
 }
 function parseCreateFromData(data, metadata) {
@@ -199,6 +266,10 @@ function parseCreateFromData(data, metadata) {
     const is_mayhem_mode = (0, binary_js_1.readBool)(data, o) ?? false;
     o += 1;
     const is_cashback_enabled = (0, binary_js_1.readBool)(data, o) ?? false;
+    o += 1;
+    const quote_mint = o + 32 <= data.length ? (0, binary_js_1.readPubkey)(data, o) : (0, dex_event_js_1.defaultPubkey)();
+    o += 32;
+    const virtual_quote_reserves = o + 8 <= data.length ? bnU64((0, binary_js_1.readU64LE)(data, o)) : 0n;
     const ev = {
         metadata,
         name: n1.s,
@@ -216,6 +287,8 @@ function parseCreateFromData(data, metadata) {
         token_program,
         is_mayhem_mode,
         is_cashback_enabled,
+        quote_mint,
+        virtual_quote_reserves,
     };
     return { PumpFunCreate: ev };
 }

package/dist/logs/pump_amm.js

@@ -18,7 +18,7 @@ function bnI64(v) {
 }
 const ZP = (0, dex_event_js_1.defaultPubkey)();
 function parseBuyFromData(data, metadata) {
-    const MIN = 14 * 8 + 7 * 32 + 1 + 5 * 8 + 4;
+    const MIN = 16 * 8 + 7 * 32 + 1 + 5 * 8 + 4;
     if (data.length < MIN)
         return null;
     let o = 0;

package/dist/logs/raydium_launchlab.d.ts

@@ -0,0 +1,10 @@
+/** Raydium LaunchLab 日志解析 */
+import type { EventMetadata } from "../core/metadata.js";
+import type { DexEvent } from "../core/dex_event.js";
+export declare const RAYDIUM_LAUNCHLAB_DISC: {
+    TRADE: bigint;
+    POOL_CREATE: bigint;
+};
+export declare function parseRaydiumLaunchlabTradeFromData(data: Uint8Array, metadata: EventMetadata): DexEvent | null;
+export declare function parseRaydiumLaunchlabPoolCreateFromData(data: Uint8Array, metadata: EventMetadata): DexEvent | null;
+export declare function parseRaydiumLaunchlabFromDiscriminator(discriminator: bigint, data: Uint8Array, metadata: EventMetadata): DexEvent | null;

package/dist/logs/raydium_launchlab.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAYDIUM_LAUNCHLAB_DISC = void 0;
+exports.parseRaydiumLaunchlabTradeFromData = parseRaydiumLaunchlabTradeFromData;
+exports.parseRaydiumLaunchlabPoolCreateFromData = parseRaydiumLaunchlabPoolCreateFromData;
+exports.parseRaydiumLaunchlabFromDiscriminator = parseRaydiumLaunchlabFromDiscriminator;
+const binary_js_1 = require("../util/binary.js");
+function disc(bytes) {
+    const u8 = new Uint8Array(8);
+    for (let i = 0; i < 8; i++)
+        u8[i] = bytes[i];
+    return new DataView(u8.buffer).getBigUint64(0, true);
+}
+exports.RAYDIUM_LAUNCHLAB_DISC = {
+    TRADE: disc([189, 219, 127, 211, 78, 230, 97, 238]),
+    POOL_CREATE: disc([151, 215, 226, 9, 118, 161, 115, 174]),
+};
+function bn64(v) {
+    return v ?? 0n;
+}
+function parseRaydiumLaunchlabTradeFromData(data, metadata) {
+    const pool_state = (0, binary_js_1.readPubkey)(data, 0);
+    const amount_in = (0, binary_js_1.readU64LE)(data, 88);
+    const amount_out = (0, binary_js_1.readU64LE)(data, 96);
+    const trade_direction = (0, binary_js_1.readU8)(data, 136);
+    const exact_in = (0, binary_js_1.readBool)(data, 138);
+    if (!pool_state || amount_in === null || amount_out === null || trade_direction === null || exact_in === null) {
+        return null;
+    }
+    const is_buy = trade_direction === 0;
+    const ev = {
+        metadata,
+        pool_state,
+        user: "11111111111111111111111111111111",
+        amount_in: bn64(amount_in),
+        amount_out: bn64(amount_out),
+        is_buy,
+        trade_direction: is_buy ? "Buy" : "Sell",
+        exact_in,
+    };
+    return { RaydiumLaunchlabTrade: ev };
+}
+function parseRaydiumLaunchlabPoolCreateFromData(data, metadata) {
+    if (data.length < 97)
+        return null;
+    let o = 0;
+    const pool_state = (0, binary_js_1.readPubkey)(data, o);
+    o += 32;
+    const creator = (0, binary_js_1.readPubkey)(data, o);
+    o += 32;
+    const config = (0, binary_js_1.readPubkey)(data, o);
+    if (!pool_state || !creator || !config)
+        return null;
+    o += 32;
+    const decimals = (0, binary_js_1.readU8)(data, o);
+    if (decimals === null)
+        return null;
+    o += 1;
+    const name = (0, binary_js_1.readBorshString)(data, o);
+    if (!name)
+        return null;
+    o = name.next;
+    const symbol = (0, binary_js_1.readBorshString)(data, o);
+    if (!symbol)
+        return null;
+    o = symbol.next;
+    const uri = (0, binary_js_1.readBorshString)(data, o);
+    if (!uri)
+        return null;
+    const ev = {
+        metadata,
+        base_mint_param: { symbol: symbol.s, name: name.s, uri: uri.s, decimals },
+        pool_state,
+        creator,
+    };
+    return { RaydiumLaunchlabPoolCreate: ev };
+}
+function parseRaydiumLaunchlabFromDiscriminator(discriminator, data, metadata) {
+    if (discriminator === exports.RAYDIUM_LAUNCHLAB_DISC.TRADE)
+        return parseRaydiumLaunchlabTradeFromData(data, metadata);
+    if (discriminator === exports.RAYDIUM_LAUNCHLAB_DISC.POOL_CREATE)
+        return parseRaydiumLaunchlabPoolCreateFromData(data, metadata);
+    return null;
+}

package/dist/shredstream/client.d.ts

@@ -1,4 +1,5 @@
 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 = {
@@ -48,7 +49,9 @@ export declare class ShredStreamClient {
      * 订阅 DEX 事件（自动重连）；返回队列供轮询消费（与 Rust `subscribe` 一致）。
      * 重连循环使用订阅时刻的配置快照（与 Rust 在 `tokio::spawn` 前 `config.clone()` 一致）。
      */
-    subscribe(): Promise<ShredEventQueue>;
+    subscribe(eventTypeFilter?: EventTypeFilter): Promise<ShredEventQueue>;
+    /** 与 Rust `subscribe_with_filter` 对齐：在解析热路径按事件类型预过滤。 */
+    subscribeWithFilter(eventTypeFilter?: EventTypeFilter): Promise<ShredEventQueue>;
     /** 停止订阅并中止当前流 */
     stop(): Promise<void>;
     private runReconnectLoop;

package/dist/shredstream/client.js

@@ -193,7 +193,7 @@ class ShredStreamClient {
      * 订阅 DEX 事件（自动重连）；返回队列供轮询消费（与 Rust `subscribe` 一致）。
      * 重连循环使用订阅时刻的配置快照（与 Rust 在 `tokio::spawn` 前 `config.clone()` 一致）。
      */
-    async subscribe() {
+    async subscribe(eventTypeFilter) {
         await this.stop();
         this.receiveStats = {
             entryMessagesReceived: 0,
@@ -205,9 +205,13 @@ class ShredStreamClient {
         const ac = new AbortController();
         this.loopAbort = ac;
         const configSnapshot = { ...this.config };
-        this.loopPromise = this.runReconnectLoop(queue, ac.signal, configSnapshot);
+        this.loopPromise = this.runReconnectLoop(queue, ac.signal, configSnapshot, eventTypeFilter);
         return queue;
     }
+    /** 与 Rust `subscribe_with_filter` 对齐：在解析热路径按事件类型预过滤。 */
+    async subscribeWithFilter(eventTypeFilter) {
+        return this.subscribe(eventTypeFilter);
+    }
     /** 停止订阅并中止当前流 */
     async stop() {
         this.loopAbort?.abort();
@@ -219,7 +223,7 @@ class ShredStreamClient {
             this.loopPromise = null;
         }
     }
-    async runReconnectLoop(queue, signal, config) {
+    async runReconnectLoop(queue, signal, config, eventTypeFilter) {
         let delay = config.reconnect_delay_ms;
         let attempts = 0;
         while (!signal.aborted) {
@@ -230,7 +234,7 @@ class ShredStreamClient {
             }
             attempts += 1;
             try {
-                await this.streamOnce(queue, signal, config);
+                await this.streamOnce(queue, signal, config, eventTypeFilter);
                 delay = config.reconnect_delay_ms;
                 attempts = 0;
             }
@@ -247,7 +251,7 @@ class ShredStreamClient {
         }
     }
     /** 与 Rust `stream_events` + `connect_with_config`（tonic Endpoint / Grpc 消息上限）一致 */
-    streamOnce(queue, signal, config) {
+    streamOnce(queue, signal, config, eventTypeFilter) {
         if (signal.aborted)
             return Promise.resolve();
         const target = grpcTarget(this.endpoint);
@@ -272,7 +276,7 @@ class ShredStreamClient {
                 if (signal.aborted)
                     return;
                 try {
-                    void this.processEntryMessage(entry, queue);
+                    void this.processEntryMessage(entry, queue, eventTypeFilter);
                 }
                 catch (err) {
                     console.error("processEntryMessage:", err);
@@ -293,7 +297,7 @@ class ShredStreamClient {
             });
         });
     }
-    async processEntryMessage(entry, queue) {
+    async processEntryMessage(entry, queue, eventTypeFilter) {
         this.receiveStats.entryMessagesReceived += 1;
         const recvUs = (0, unified_parser_js_1.nowUs)();
         const slotNum = toSlotNumber(entry.slot);
@@ -312,18 +316,18 @@ class ShredStreamClient {
         const conn = this.config.connection;
         if (conn) {
             try {
-                await this.processEntryMessageWithAlt(decoded, slotNum, recvUs, queue, bytes.length, conn);
+                await this.processEntryMessageWithAlt(decoded, slotNum, recvUs, queue, bytes.length, conn, eventTypeFilter);
             }
             catch (e) {
                 console.warn(`[shredstream] ALT/RPC 解析失败 slot=${slotNum}:`, e);
-                this.processEntryMessageSync(decoded, slotNum, recvUs, queue, bytes.length);
+                this.processEntryMessageSync(decoded, slotNum, recvUs, queue, bytes.length, eventTypeFilter);
             }
             return;
         }
-        this.processEntryMessageSync(decoded, slotNum, recvUs, queue, bytes.length);
+        this.processEntryMessageSync(decoded, slotNum, recvUs, queue, bytes.length, eventTypeFilter);
     }
     /** 无 RPC：仅用静态账户表 */
-    processEntryMessageSync(decoded, slotNum, recvUs, queue, entriesBytesLen) {
+    processEntryMessageSync(decoded, slotNum, recvUs, queue, entriesBytesLen, eventTypeFilter) {
         let txTotal = 0;
         let evTotal = 0;
         /** 与 golang `shredstream_entries` 一致：单条 gRPC 消息内跨所有 Solana Entry 的连续下标 */
@@ -336,7 +340,7 @@ class ShredStreamClient {
                 const txIndex = globalTxIndex++;
                 if (!tx?.signature)
                     continue;
-                const events = (0, instruction_parse_js_1.dexEventsFromShredWasmTx)(tx, slotNum, txIndex, recvUs, undefined);
+                const events = (0, instruction_parse_js_1.dexEventsFromShredWasmTx)(tx, slotNum, txIndex, recvUs, eventTypeFilter);
                 evTotal += events.length;
                 for (const ev of events) {
                     setGrpcRecvUsMut(ev, recvUs);
@@ -351,7 +355,7 @@ class ShredStreamClient {
         }
     }
     /** 拉取 ALT 后完整账户表解析 */
-    async processEntryMessageWithAlt(decoded, slotNum, recvUs, queue, entriesBytesLen, conn) {
+    async processEntryMessageWithAlt(decoded, slotNum, recvUs, queue, entriesBytesLen, conn, eventTypeFilter) {
         const altKeys = new Set();
         for (const outer of decoded) {
             for (const tx of outer) {
@@ -373,7 +377,7 @@ class ShredStreamClient {
                 if (!tx?.signature)
                     continue;
                 const fullKeys = (0, alt_lookup_js_1.fullAccountKeyStringsFromShredTx)(tx, altMap);
-                const events = (0, instruction_parse_js_1.dexEventsFromShredWasmTxWithFullKeys)(tx, fullKeys, slotNum, txIndex, recvUs, undefined);
+                const events = (0, instruction_parse_js_1.dexEventsFromShredWasmTxWithFullKeys)(tx, fullKeys, slotNum, txIndex, recvUs, eventTypeFilter);
                 evTotal += events.length;
                 for (const ev of events) {
                     setGrpcRecvUsMut(ev, recvUs);

package/dist/shredstream/index.d.ts

@@ -5,7 +5,7 @@
  * - 仅静态账户键；使用 ALT 的交易账户列表不完整
  * - 无 inner instructions，无法 CPI 解析
  * - 无 block_time
- * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则跳过该指令）
+ * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则用默认 pubkey best-effort）
  * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
  */
 export { type ShredStreamConfig, defaultShredStreamConfig, lowLatencyShredStreamConfig, highThroughputShredStreamConfig, } from "./config.js";

package/dist/shredstream/index.js

@@ -8,7 +8,7 @@ exports.wireBytesToShredWasmTx = exports.decodeShredstreamEntriesBincode = expor
  * - 仅静态账户键；使用 ALT 的交易账户列表不完整
  * - 无 inner instructions，无法 CPI 解析
  * - 无 block_time
- * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则跳过该指令）
+ * - 无交易日志（program logs）；客户端对每条交易走 **外层 `parseInstructionUnified`**（与 gRPC 指令解析同源），可产出 `DexEvent`（V0+ALT 若账户下标超出静态表则用默认 pubkey best-effort）
  * - `metadata.tx_index` 为**单条 gRPC `Entry` 消息内**跨所有 Solana `Entry` 分组的连续下标（与 golang `shredstream_entries` 扁平 `ti` 对齐），非 slot 级全局序号
  */
 var config_js_1 = require("./config.js");

package/dist/shredstream/instruction_parse.d.ts

@@ -1,10 +1,10 @@
 /**
  * ShredStream：外层编译指令 → `parseInstructionUnified`（与 gRPC 指令解析同源）。
  * `ShredWasmTx` 来自线格式交易经 `@solana/web3.js` 反序列化（见 `wire_to_shred_tx.ts`），非 WASM。
- * 完整账户列表需含 V0 ALT 展开，见 `alt_lookup.ts` + `ShredStreamConfig.connection`。
+ * 有 `ShredStreamConfig.connection` 时可展开 V0 ALT；无 RPC 时用静态账户表 + 默认 pubkey best-effort。
  */
 import type { MessageHeader } from "@solana/web3.js";
-import type { DexEvent } from "../core/dex_event.js";
+import { type DexEvent } from "../core/dex_event.js";
 import type { EventTypeFilter } from "../grpc/types.js";
 export type ShredWasmCompiledIx = {
     programIdIndex: number;
@@ -30,5 +30,5 @@ export type ShredWasmTx = {
  * 使用已解析的完整账户表（静态+ALT）解析外层指令。
  */
 export declare function dexEventsFromShredWasmTxWithFullKeys(tx: ShredWasmTx, fullAccountKeys: string[], slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];
-/** 仅静态账户表（无 RPC 时；V0+ALT 交易多数指令无法解析） */
+/** 仅静态账户表（无 RPC 时；V0+ALT 缺失账户以默认 pubkey 占位） */
 export declare function dexEventsFromShredWasmTx(tx: ShredWasmTx, slot: number, txIndex: number, grpcRecvUs: number, eventTypeFilter?: EventTypeFilter): DexEvent[];

package/dist/shredstream/instruction_parse.js

@@ -2,13 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dexEventsFromShredWasmTxWithFullKeys = dexEventsFromShredWasmTxWithFullKeys;
 exports.dexEventsFromShredWasmTx = dexEventsFromShredWasmTx;
+const dex_event_js_1 = require("../core/dex_event.js");
 const pumpfun_fee_enrich_js_1 = require("../core/pumpfun_fee_enrich.js");
 const mod_js_1 = require("../instr/mod.js");
+const program_ids_js_1 = require("../instr/program_ids.js");
 function asU8(b) {
     if (b instanceof Uint8Array)
         return b;
     return Uint8Array.from(b);
 }
+const UNKNOWN_PROGRAM_CANDIDATES = [
+    program_ids_js_1.PUMPFUN_PROGRAM_ID,
+    program_ids_js_1.PUMPSWAP_PROGRAM_ID,
+    program_ids_js_1.PUMP_FEES_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_LAUNCHLAB_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_CPMM_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_CLMM_PROGRAM_ID,
+    program_ids_js_1.RAYDIUM_AMM_V4_PROGRAM_ID,
+    program_ids_js_1.ORCA_WHIRLPOOL_PROGRAM_ID,
+    program_ids_js_1.METEORA_POOLS_PROGRAM_ID,
+    program_ids_js_1.METEORA_DAMM_V2_PROGRAM_ID,
+    program_ids_js_1.METEORA_DLMM_PROGRAM_ID,
+];
+const SHRED_DEFAULT_PUBKEY = (0, dex_event_js_1.defaultPubkey)();
+function ixAccountStrings(fullAccountKeys, accBytes) {
+    const accountStrs = [];
+    for (let i = 0; i < accBytes.length; i++) {
+        const ai = accBytes[i];
+        accountStrs.push(ai < fullAccountKeys.length ? fullAccountKeys[ai] : SHRED_DEFAULT_PUBKEY);
+    }
+    return accountStrs;
+}
 /**
  * 使用已解析的完整账户表（静态+ALT）解析外层指令。
  */
@@ -19,23 +43,22 @@ function dexEventsFromShredWasmTxWithFullKeys(tx, fullAccountKeys, slot, txIndex
     const out = [];
     for (const rawIx of ixs) {
         const pidIdx = rawIx.programIdIndex;
-        if (!Number.isFinite(pidIdx) || pidIdx < 0 || pidIdx >= fullAccountKeys.length)
+        if (!Number.isFinite(pidIdx) || pidIdx < 0)
             continue;
-        const programId = fullAccountKeys[pidIdx];
         const accBytes = asU8(rawIx.accounts);
         const data = asU8(rawIx.data);
-        const accountStrs = [];
-        let oob = false;
-        for (let i = 0; i < accBytes.length; i++) {
-            const ai = accBytes[i];
-            if (ai >= fullAccountKeys.length) {
-                oob = true;
-                break;
+        const accountStrs = ixAccountStrings(fullAccountKeys, accBytes);
+        if (pidIdx >= fullAccountKeys.length) {
+            for (const programId of UNKNOWN_PROGRAM_CANDIDATES) {
+                const ev = (0, mod_js_1.parseInstructionUnified)(data, accountStrs, tx.signature, slot, txIndex, undefined, grpcRecvUs, eventTypeFilter, programId);
+                if (ev) {
+                    out.push(ev);
+                    break;
+                }
             }
-            accountStrs.push(fullAccountKeys[ai]);
-        }
-        if (oob)
             continue;
+        }
+        const programId = fullAccountKeys[pidIdx];
         const ev = (0, mod_js_1.parseInstructionUnified)(data, accountStrs, tx.signature, slot, txIndex, undefined, grpcRecvUs, eventTypeFilter, programId);
         if (ev)
             out.push(ev);
@@ -43,7 +66,7 @@ function dexEventsFromShredWasmTxWithFullKeys(tx, fullAccountKeys, slot, txIndex
     (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(out);
     return out;
 }
-/** 仅静态账户表（无 RPC 时；V0+ALT 交易多数指令无法解析） */
+/** 仅静态账户表（无 RPC 时；V0+ALT 缺失账户以默认 pubkey 占位） */
 function dexEventsFromShredWasmTx(tx, slot, txIndex, grpcRecvUs, eventTypeFilter) {
     return dexEventsFromShredWasmTxWithFullKeys(tx, tx.accounts, slot, txIndex, grpcRecvUs, eventTypeFilter);
 }

package/dist/util/market.d.ts

@@ -0,0 +1,18 @@
+export type NumericAmount = bigint | number | string;
+export type NormalizedTradeSide = "Buy" | "Sell";
+/**
+ * Convert a Q64.64 sqrt price into quote-token units per one base token.
+ */
+export declare function sqrtPriceX64ToPrice(sqrtPriceX64: NumericAmount, baseDecimals: number, quoteDecimals: number): number;
+/**
+ * Compute quote-token price per one base token from raw vault balances.
+ */
+export declare function vaultPriceFromBalances(baseRaw: NumericAmount, quoteRaw: NumericAmount, baseDecimals: number, quoteDecimals: number): number | undefined;
+/**
+ * Positive watched-token delta means Buy; negative means Sell.
+ */
+export declare function normalizeBuySellFromTokenDelta(tokenDelta: NumericAmount): NormalizedTradeSide | undefined;
+/**
+ * If input is quote, the user buys base. If input is base, the user sells base.
+ */
+export declare function normalizeBuySellFromInputMint(inputMint: string, baseMint: string, quoteMint: string): NormalizedTradeSide | undefined;

package/dist/util/market.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrtPriceX64ToPrice = sqrtPriceX64ToPrice;
+exports.vaultPriceFromBalances = vaultPriceFromBalances;
+exports.normalizeBuySellFromTokenDelta = normalizeBuySellFromTokenDelta;
+exports.normalizeBuySellFromInputMint = normalizeBuySellFromInputMint;
+function amountToNumber(value) {
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "number")
+        return value;
+    if (value.trim() === "")
+        throw new Error("amount must not be empty");
+    return Number(value);
+}
+/**
+ * Convert a Q64.64 sqrt price into quote-token units per one base token.
+ */
+function sqrtPriceX64ToPrice(sqrtPriceX64, baseDecimals, quoteDecimals) {
+    const sqrt = amountToNumber(sqrtPriceX64) / 2 ** 64;
+    return sqrt * sqrt * 10 ** (baseDecimals - quoteDecimals);
+}
+/**
+ * Compute quote-token price per one base token from raw vault balances.
+ */
+function vaultPriceFromBalances(baseRaw, quoteRaw, baseDecimals, quoteDecimals) {
+    const base = amountToNumber(baseRaw);
+    if (base === 0)
+        return undefined;
+    return (amountToNumber(quoteRaw) / base) * 10 ** (baseDecimals - quoteDecimals);
+}
+/**
+ * Positive watched-token delta means Buy; negative means Sell.
+ */
+function normalizeBuySellFromTokenDelta(tokenDelta) {
+    const delta = amountToNumber(tokenDelta);
+    if (delta > 0)
+        return "Buy";
+    if (delta < 0)
+        return "Sell";
+    return undefined;
+}
+/**
+ * If input is quote, the user buys base. If input is base, the user sells base.
+ */
+function normalizeBuySellFromInputMint(inputMint, baseMint, quoteMint) {
+    if (baseMint === quoteMint)
+        return undefined;
+    if (inputMint === quoteMint)
+        return "Buy";
+    if (inputMint === baseMint)
+        return "Sell";
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol-parser-sdk-nodejs",
-  "version": "0.4.4",
+  "version": "0.5.5",
   "description": "High-performance Solana DEX event parser for Node.js/TypeScript (Yellowstone gRPC, log parsing)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",