sol-parser-sdk-nodejs 0.4.0 → 0.5.5

package/dist/core/pumpfun_fee_enrich.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichCreateV2FromCreateEvents = enrichCreateV2FromCreateEvents;
+exports.enrichCreateV2ObservedFeeRecipient = enrichCreateV2ObservedFeeRecipient;
+exports.enrichPumpfunTradesFromCreateInstructions = enrichPumpfunTradesFromCreateInstructions;
+exports.enrichPumpfunSameTxPostMerge = enrichPumpfunSameTxPostMerge;
+const dex_event_js_1 = require("./dex_event.js");
+function pumpfunTradeEvent(ev) {
+    if ("PumpFunTrade" in ev)
+        return ev.PumpFunTrade;
+    if ("PumpFunBuy" in ev)
+        return ev.PumpFunBuy;
+    if ("PumpFunSell" in ev)
+        return ev.PumpFunSell;
+    if ("PumpFunBuyExactSolIn" in ev)
+        return ev.PumpFunBuyExactSolIn;
+    return null;
+}
+function pumpfunCreateFlags(ev) {
+    let c = null;
+    if ("PumpFunCreate" in ev)
+        c = ev.PumpFunCreate;
+    if ("PumpFunCreateV2" in ev)
+        c = ev.PumpFunCreateV2;
+    if (!c || !c.mint || c.mint === (0, dex_event_js_1.defaultPubkey)())
+        return null;
+    return [c.mint, c.is_cashback_enabled, c.is_mayhem_mode];
+}
+function fillString(dst, key, value) {
+    const zero = (0, dex_event_js_1.defaultPubkey)();
+    if ((!dst[key] || dst[key] === zero) && value && value !== zero) {
+        dst[key] = value;
+    }
+}
+function fillBigint(dst, key, value) {
+    if (dst[key] === 0n && value !== 0n) {
+        dst[key] = value;
+    }
+}
+function enrichCreateV2FromCreateEvents(events) {
+    const zero = (0, dex_event_js_1.defaultPubkey)();
+    const creates = new Map();
+    for (const ev of events) {
+        if (!("PumpFunCreate" in ev))
+            continue;
+        const c = ev.PumpFunCreate;
+        if (c.mint && c.mint !== zero && !creates.has(c.mint)) {
+            creates.set(c.mint, c);
+        }
+    }
+    if (creates.size === 0)
+        return;
+    for (const ev of events) {
+        if (!("PumpFunCreateV2" in ev))
+            continue;
+        const c2 = ev.PumpFunCreateV2;
+        const c = creates.get(c2.mint);
+        if (!c)
+            continue;
+        fillString(c2, "name", c.name);
+        fillString(c2, "symbol", c.symbol);
+        fillString(c2, "uri", c.uri);
+        fillString(c2, "bonding_curve", c.bonding_curve);
+        fillString(c2, "user", c.user);
+        fillString(c2, "creator", c.creator);
+        fillString(c2, "token_program", c.token_program);
+        fillString(c2, "quote_mint", c.quote_mint);
+        fillBigint(c2, "timestamp", c.timestamp);
+        fillBigint(c2, "virtual_token_reserves", c.virtual_token_reserves);
+        fillBigint(c2, "virtual_sol_reserves", c.virtual_sol_reserves);
+        fillBigint(c2, "real_token_reserves", c.real_token_reserves);
+        fillBigint(c2, "token_total_supply", c.token_total_supply);
+        fillBigint(c2, "virtual_quote_reserves", c.virtual_quote_reserves);
+        c2.is_mayhem_mode ||= c.is_mayhem_mode;
+        c2.is_cashback_enabled ||= c.is_cashback_enabled;
+    }
+}
+function enrichCreateV2ObservedFeeRecipient(events) {
+    const zero = (0, dex_event_js_1.defaultPubkey)();
+    const mintToFee = new Map();
+    for (const ev of events) {
+        const t = pumpfunTradeEvent(ev);
+        if (!t || !t.mint || t.mint === zero || !t.fee_recipient || t.fee_recipient === zero) {
+            continue;
+        }
+        const buyLike = ("PumpFunTrade" in ev && t.is_buy) ||
+            "PumpFunBuy" in ev ||
+            "PumpFunBuyExactSolIn" in ev;
+        if (buyLike && !mintToFee.has(t.mint)) {
+            mintToFee.set(t.mint, t.fee_recipient);
+        }
+    }
+    if (mintToFee.size === 0)
+        return;
+    for (const ev of events) {
+        if (!("PumpFunCreateV2" in ev))
+            continue;
+        const c = ev.PumpFunCreateV2;
+        if (!c.observed_fee_recipient || c.observed_fee_recipient === zero) {
+            c.observed_fee_recipient = mintToFee.get(c.mint) ?? c.observed_fee_recipient;
+        }
+    }
+}
+function enrichPumpfunTradesFromCreateInstructions(events) {
+    const flags = new Map();
+    for (const ev of events) {
+        const f = pumpfunCreateFlags(ev);
+        if (f && !flags.has(f[0]))
+            flags.set(f[0], [f[1], f[2]]);
+    }
+    if (flags.size === 0)
+        return;
+    for (const ev of events) {
+        const t = pumpfunTradeEvent(ev);
+        if (!t || !t.mint || t.mint === (0, dex_event_js_1.defaultPubkey)())
+            continue;
+        const f = flags.get(t.mint);
+        if (!f)
+            continue;
+        const [cashbackEnabled, mayhemMode] = f;
+        t.is_cashback_coin ||= cashbackEnabled;
+        t.mayhem_mode ||= mayhemMode;
+        if (cashbackEnabled)
+            t.track_volume = true;
+    }
+}
+function enrichPumpfunSameTxPostMerge(events) {
+    enrichCreateV2FromCreateEvents(events);
+    enrichCreateV2ObservedFeeRecipient(events);
+    enrichPumpfunTradesFromCreateInstructions(events);
+}

package/dist/core/unified_parser.js

@@ -8,6 +8,7 @@ exports.parseTransactionEventsStreaming = parseTransactionEventsStreaming;
 exports.parseLogsStreaming = parseLogsStreaming;
 exports.parseTransactionWithStreamingListener = parseTransactionWithStreamingListener;
 exports.parseLog = parseLog;
+const pumpfun_fee_enrich_js_1 = require("./pumpfun_fee_enrich.js");
 const optimized_matcher_js_1 = require("../logs/optimized_matcher.js");
 const clock_js_1 = require("./clock.js");
 Object.defineProperty(exports, "nowUs", { enumerable: true, get: function () { return clock_js_1.nowUs; } });
@@ -22,6 +23,7 @@ function parseLogsOnly(logs, signature, slot, blockTimeUs, txIndex = 0) {
         if (e)
             out.push(e);
     }
+    (0, pumpfun_fee_enrich_js_1.enrichPumpfunSameTxPostMerge)(out);
     return out;
 }
 function parseTransactionWithListener(instructionData, accounts, logs, signature, slot, txIndex, blockTimeUs, programId, listener) {

package/dist/grpc/client.d.ts

@@ -2,14 +2,22 @@
  * Yellowstone gRPC 客户端实现 - 基于 @triton-one/yellowstone-grpc
  */
 import { CommitmentLevel } from "@triton-one/yellowstone-grpc";
-import { type ClientConfig, type TransactionFilter, type SubscribeCallbacks } from "./types.js";
+import type { DexEvent } from "../core/dex_event.js";
+import { type AccountFilter, type ClientConfig, type EventTypeFilter, type TransactionFilter, type SubscribeCallbacks } from "./types.js";
 export { SubscribeCallbacks };
+export interface DexEventSubscription extends AsyncIterable<DexEvent> {
+    id: string;
+    errors: AsyncIterable<Error>;
+    cancel(): void;
+    next(): Promise<IteratorResult<DexEvent>>;
+}
 /** Yellowstone gRPC 客户端包装器 */
 export declare class YellowstoneGrpc {
     private client;
     private config;
     private connected;
     private subscribers;
+    private dexSubscribers;
     constructor(endpoint: string, xToken: string, config?: ClientConfig);
     /** 连接到 gRPC 服务器 */
     connect(): Promise<void>;
@@ -28,14 +36,31 @@ export declare class YellowstoneGrpc {
      * 若不回复，公共节点或 LB 可能在超时后 RST_STREAM（HTTP/2 CANCEL）。
      */
     private subscribePingPongRequest;
+    private static toBytes;
+    private static toBigInt;
+    private static protobufNumber;
+    private static timestampToMicros;
+    private parseAccountEvent;
     private initialSubscribeRequest;
     /** 订阅交易 */
     subscribeTransactions(filter: TransactionFilter, callbacks: SubscribeCallbacks): Promise<{
         id: string;
         cancel: () => void;
     }>;
+    /**
+     * 订阅并直接产出 `DexEvent`。
+     *
+     * 交易更新走统一交易解析（外层/内层指令 + 日志 + 数据填充）；账户更新走 `parseAccountUnified`。
+     * 事件队列满时丢弃新事件，避免回调阻塞 gRPC 读循环，保持低延迟。
+     */
+    subscribeDexEvents(transactionFilters?: TransactionFilter[], accountFilters?: AccountFilter[], eventTypeFilter?: EventTypeFilter, options?: {
+        autoReconnect?: boolean;
+    }): Promise<DexEventSubscription>;
     /** 取消订阅 */
     unsubscribe(subId: string): void;
+    /** 动态更新当前 DEX 订阅过滤器（与 Rust update_subscription 语义对齐）。 */
+    updateSubscription(transactionFilters: TransactionFilter[], accountFilters: AccountFilter[]): Promise<void>;
+    update_subscription(transactionFilters: TransactionFilter[], accountFilters: AccountFilter[]): Promise<void>;
     /** 获取最新区块哈希 */
     getLatestBlockhash(commitment?: CommitmentLevel): Promise<{
         slot: number;

package/dist/grpc/client.js

@@ -32,20 +32,72 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YellowstoneGrpc = void 0;
 /**
  * Yellowstone gRPC 客户端实现 - 基于 @triton-one/yellowstone-grpc
  */
 const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
+const bs58_1 = __importDefault(require("bs58"));
+const metadata_js_1 = require("../core/metadata.js");
+const mod_js_1 = require("../accounts/mod.js");
 const geyser_connect_js_1 = require("./geyser_connect.js");
+const order_buffer_js_1 = require("./order_buffer.js");
+const subscribe_builder_js_1 = require("./subscribe_builder.js");
+const yellowstone_parse_js_1 = require("./yellowstone_parse.js");
 const types_js_1 = require("./types.js");
+class AsyncEventQueue {
+    maxSize;
+    items = [];
+    waiters = [];
+    closed = false;
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+    }
+    push(item) {
+        if (this.closed)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({ value: item, done: false });
+            return;
+        }
+        if (this.items.length < this.maxSize) {
+            this.items.push(item);
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0)) {
+            waiter({ value: undefined, done: true });
+        }
+    }
+    next() {
+        const item = this.items.shift();
+        if (item !== undefined) {
+            return Promise.resolve({ value: item, done: false });
+        }
+        if (this.closed) {
+            return Promise.resolve({ value: undefined, done: true });
+        }
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+}
 /** Yellowstone gRPC 客户端包装器 */
 class YellowstoneGrpc {
     client;
     config;
     connected = false;
     subscribers = new Map();
+    dexSubscribers = new Map();
     constructor(endpoint, xToken, config = (0, types_js_1.defaultClientConfig)()) {
         this.config = config;
         const gc = (0, geyser_connect_js_1.defaultGeyserConnectConfig)();
@@ -68,6 +120,10 @@ class YellowstoneGrpc {
             sub.cancel();
         }
         this.subscribers.clear();
+        for (const [, sub] of this.dexSubscribers) {
+            sub.cancel();
+        }
+        this.dexSubscribers.clear();
         this.connected = false;
     }
     /** 检查是否已连接 */
@@ -96,6 +152,9 @@ class YellowstoneGrpc {
         const result = {
             filters: update.filters,
         };
+        const createdAtUs = YellowstoneGrpc.timestampToMicros(update.createdAt ?? update.created_at);
+        if (createdAtUs !== undefined)
+            result.createdAtUs = createdAtUs;
         if (update.account) {
             const acc = update.account;
             result.account = {
@@ -191,6 +250,58 @@ class YellowstoneGrpc {
             ping: { id: 1 },
         };
     }
+    static toBytes(value) {
+        if (!value)
+            return new Uint8Array();
+        return value instanceof Uint8Array ? value : Uint8Array.from(value);
+    }
+    static toBigInt(value) {
+        return typeof value === "bigint" ? value : BigInt(value);
+    }
+    static protobufNumber(value) {
+        if (typeof value === "bigint")
+            return Number(value);
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string")
+            return Number(value);
+        if (value && typeof value === "object") {
+            const longLike = value;
+            if (typeof longLike.toNumber === "function")
+                return longLike.toNumber();
+            if (typeof longLike.toString === "function")
+                return Number(longLike.toString());
+        }
+        return Number.NaN;
+    }
+    static timestampToMicros(value) {
+        if (!value || typeof value !== "object")
+            return undefined;
+        const ts = value;
+        if (ts.seconds === undefined)
+            return undefined;
+        const seconds = YellowstoneGrpc.protobufNumber(ts.seconds);
+        const nanos = Number(ts.nanos ?? 0);
+        if (!Number.isFinite(seconds) || !Number.isFinite(nanos))
+            return undefined;
+        return Math.trunc(seconds * 1_000_000 + nanos / 1_000);
+    }
+    parseAccountEvent(update, grpcRecvUs, eventTypeFilter, blockTimeUs) {
+        const acc = update.account;
+        if (!acc)
+            return null;
+        const signatureBytes = YellowstoneGrpc.toBytes(acc.txnSignature);
+        const account = {
+            pubkey: bs58_1.default.encode(YellowstoneGrpc.toBytes(acc.pubkey)),
+            executable: acc.executable,
+            lamports: YellowstoneGrpc.toBigInt(acc.lamports),
+            owner: bs58_1.default.encode(YellowstoneGrpc.toBytes(acc.owner)),
+            rent_epoch: YellowstoneGrpc.toBigInt(acc.rentEpoch),
+            data: YellowstoneGrpc.toBytes(acc.data),
+        };
+        const metadata = (0, metadata_js_1.makeMetadata)(signatureBytes.length > 0 ? bs58_1.default.encode(signatureBytes) : "", Number(update.slot), 0, blockTimeUs, grpcRecvUs);
+        return (0, mod_js_1.parseAccountUnified)(account, metadata, eventTypeFilter);
+    }
     initialSubscribeRequest(filter) {
         return {
             transactions: {
@@ -317,6 +428,158 @@ class YellowstoneGrpc {
             },
         };
     }
+    /**
+     * 订阅并直接产出 `DexEvent`。
+     *
+     * 交易更新走统一交易解析（外层/内层指令 + 日志 + 数据填充）；账户更新走 `parseAccountUnified`。
+     * 事件队列满时丢弃新事件，避免回调阻塞 gRPC 读循环，保持低延迟。
+     */
+    async subscribeDexEvents(transactionFilters = [], accountFilters = [], eventTypeFilter, options) {
+        await this.connect();
+        const id = `dex_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        const events = new AsyncEventQueue(Math.max(1, this.config.buffer_size));
+        const errors = new AsyncEventQueue(Math.max(1, this.config.buffer_size));
+        const order = new order_buffer_js_1.OrderDispatcher(this.config);
+        const emitEvent = (event) => events.push(event);
+        let flushTimer;
+        if (order.needsTimer) {
+            const intervalMs = this.config.order_mode === "MicroBatch"
+                ? Math.max(1, Math.ceil(this.config.micro_batch_us / 1000))
+                : Math.max(1, Math.floor(this.config.order_timeout_ms / 2));
+            flushTimer = setInterval(() => order.flushDue(emitEvent), intervalMs);
+        }
+        let isCancelled = false;
+        let currentTransactionFilters = transactionFilters;
+        let currentAccountFilters = accountFilters;
+        const streamHolder = { current: null };
+        const cancel = () => {
+            isCancelled = true;
+            streamHolder.current?.end();
+            streamHolder.current = null;
+            if (flushTimer)
+                clearInterval(flushTimer);
+            events.close();
+            errors.close();
+        };
+        const update = async (nextTxFilters, nextAccFilters) => {
+            currentTransactionFilters = nextTxFilters;
+            currentAccountFilters = nextAccFilters;
+            const stream = streamHolder.current;
+            if (!stream)
+                return;
+            await new Promise((resolve, reject) => {
+                stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        };
+        this.dexSubscribers.set(id, { cancel, update });
+        (async () => {
+            const autoReconnect = options?.autoReconnect !== false;
+            const maxBackoffMs = 60_000;
+            let backoffMs = this.config.retry_delay_ms;
+            try {
+                while (!isCancelled) {
+                    try {
+                        const stream = await this.client.subscribe();
+                        streamHolder.current = stream;
+                        await new Promise((resolve, reject) => {
+                            stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                        backoffMs = this.config.retry_delay_ms;
+                        await new Promise((resolve, reject) => {
+                            const cleanup = () => {
+                                stream.removeAllListeners();
+                                if (streamHolder.current === stream) {
+                                    streamHolder.current = null;
+                                }
+                            };
+                            stream.on("data", (update) => {
+                                if (isCancelled)
+                                    return;
+                                order.flushDue(emitEvent);
+                                if (update.ping) {
+                                    stream.write(this.subscribePingPongRequest(), (werr) => {
+                                        if (werr && !isCancelled) {
+                                            errors.push(werr instanceof Error ? werr : new Error(String(werr)));
+                                        }
+                                    });
+                                    return;
+                                }
+                                try {
+                                    const grpcRecvUs = Math.floor(Date.now() * 1000);
+                                    const converted = this.convertUpdate(update);
+                                    const tx = converted.transaction?.transaction;
+                                    if (tx) {
+                                        const fallbackSlot = YellowstoneGrpc.protobufNumber(converted.transaction?.slot ?? 0);
+                                        const fallbackTxIndex = YellowstoneGrpc.protobufNumber(tx.index ?? 0);
+                                        const txEvents = (0, yellowstone_parse_js_1.parseDexEventsFromGrpcTransactionInfo)(tx, converted.transaction?.slot ?? 0n, { blockTimeUs: converted.createdAtUs, grpcRecvUs, eventTypeFilter });
+                                        order.pushTransactionEvents(txEvents, fallbackSlot, fallbackTxIndex, emitEvent);
+                                    }
+                                    if (converted.account) {
+                                        const ev = this.parseAccountEvent(converted.account, grpcRecvUs, eventTypeFilter, converted.createdAtUs);
+                                        if (ev)
+                                            emitEvent(ev);
+                                    }
+                                }
+                                catch (err) {
+                                    errors.push(err instanceof Error ? err : new Error(String(err)));
+                                }
+                            });
+                            stream.on("error", (err) => {
+                                cleanup();
+                                reject(err);
+                            });
+                            stream.on("end", () => {
+                                cleanup();
+                                resolve();
+                            });
+                        });
+                    }
+                    catch (err) {
+                        if (isCancelled)
+                            break;
+                        errors.push(err instanceof Error ? err : new Error(String(err)));
+                        if (!autoReconnect)
+                            break;
+                        await new Promise((r) => setTimeout(r, backoffMs));
+                        backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                        continue;
+                    }
+                    if (isCancelled || !autoReconnect)
+                        break;
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                }
+            }
+            finally {
+                streamHolder.current?.end();
+                streamHolder.current = null;
+                if (flushTimer)
+                    clearInterval(flushTimer);
+                order.flushAll(emitEvent);
+                events.close();
+                errors.close();
+                this.dexSubscribers.delete(id);
+            }
+        })();
+        return Object.assign(events, {
+            id,
+            errors,
+            cancel: () => {
+                cancel();
+                this.dexSubscribers.delete(id);
+            },
+        });
+    }
     /** 取消订阅 */
     unsubscribe(subId) {
         const sub = this.subscribers.get(subId);
@@ -324,6 +587,22 @@ class YellowstoneGrpc {
             sub.cancel();
             this.subscribers.delete(subId);
         }
+        const dexSub = this.dexSubscribers.get(subId);
+        if (dexSub) {
+            dexSub.cancel();
+            this.dexSubscribers.delete(subId);
+        }
+    }
+    /** 动态更新当前 DEX 订阅过滤器（与 Rust update_subscription 语义对齐）。 */
+    async updateSubscription(transactionFilters, accountFilters) {
+        const active = this.dexSubscribers.values().next().value;
+        if (!active?.update) {
+            throw new Error("No active DEX subscription");
+        }
+        await active.update(transactionFilters, accountFilters);
+    }
+    async update_subscription(transactionFilters, accountFilters) {
+        await this.updateSubscription(transactionFilters, accountFilters);
     }
     /** 获取最新区块哈希 */
     async getLatestBlockhash(commitment) {

package/dist/grpc/log_instr_dedup.d.ts

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