sol-parser-sdk 0.5.9

package/dist/grpc/client.js

@@ -0,0 +1,645 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        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)();
+        this.client = new yellowstone_grpc_1.default(endpoint, xToken || undefined, (0, geyser_connect_js_1.geyserGrpcChannelOptions)({
+            ...gc,
+            keepAliveIntervalMs: config.keep_alive_interval_ms,
+            keepAliveTimeoutMs: config.keep_alive_timeout_ms,
+        }));
+    }
+    /** 连接到 gRPC 服务器 */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        this.connected = true;
+    }
+    /** 断开连接 */
+    async disconnect() {
+        for (const [, sub] of this.subscribers) {
+            sub.cancel();
+        }
+        this.subscribers.clear();
+        for (const [, sub] of this.dexSubscribers) {
+            sub.cancel();
+        }
+        this.dexSubscribers.clear();
+        this.connected = false;
+    }
+    /** 检查是否已连接 */
+    isConnected() {
+        return this.connected;
+    }
+    /** 获取客户端配置 */
+    getConfig() {
+        return this.config;
+    }
+    /** 转换 SlotStatus */
+    convertSlotStatus(status) {
+        const map = {
+            0: "Processed",
+            1: "Confirmed",
+            2: "Finalized",
+            3: "FirstShredReceived",
+            4: "Completed",
+            5: "CreatedBank",
+            6: "Dead",
+        };
+        return map[status] ?? "Processed";
+    }
+    /** 转换订阅更新 */
+    convertUpdate(update) {
+        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 = {
+                slot: acc.slot,
+                isStartup: acc.isStartup,
+            };
+            if (acc.account) {
+                result.account.account = {
+                    pubkey: acc.account.pubkey,
+                    lamports: acc.account.lamports,
+                    owner: acc.account.owner,
+                    executable: acc.account.executable,
+                    rentEpoch: acc.account.rentEpoch,
+                    data: acc.account.data,
+                    writeVersion: acc.account.writeVersion,
+                    txnSignature: acc.account.txnSignature,
+                };
+            }
+        }
+        if (update.slot) {
+            const slot = update.slot;
+            result.slot = {
+                slot: slot.slot,
+                status: this.convertSlotStatus(slot.status),
+            };
+            if (slot.parent !== undefined) {
+                result.slot.parent = slot.parent;
+            }
+            if (slot.deadError !== undefined) {
+                result.slot.deadError = slot.deadError;
+            }
+        }
+        if (update.transaction) {
+            const tx = update.transaction;
+            result.transaction = {
+                slot: tx.slot,
+            };
+            if (tx.transaction) {
+                result.transaction.transaction = {
+                    signature: tx.transaction.signature,
+                    isVote: tx.transaction.isVote,
+                    transactionRaw: tx.transaction.transaction,
+                    metaRaw: tx.transaction.meta,
+                    index: tx.transaction.index,
+                };
+            }
+        }
+        if (update.block) {
+            const block = update.block;
+            result.block = {
+                slot: block.slot,
+                blockhash: block.blockhash,
+                parentSlot: block.parentSlot,
+                parentBlockhash: block.parentBlockhash,
+                executedTransactionCount: block.executedTransactionCount,
+            };
+        }
+        if (update.blockMeta) {
+            const meta = update.blockMeta;
+            result.blockMeta = {
+                slot: meta.slot,
+                blockhash: meta.blockhash,
+                parentSlot: meta.parentSlot,
+                parentBlockhash: meta.parentBlockhash,
+                executedTransactionCount: meta.executedTransactionCount,
+            };
+        }
+        if (update.ping) {
+            result.ping = {};
+        }
+        if (update.pong) {
+            result.pong = {
+                id: update.pong.id,
+            };
+        }
+        return result;
+    }
+    /**
+     * 应答 Geyser 在 SubscribeUpdate 中下发的 ping（与 `solana-streamer` / Rust 侧一致）。
+     * 若不回复，公共节点或 LB 可能在超时后 RST_STREAM（HTTP/2 CANCEL）。
+     */
+    subscribePingPongRequest() {
+        return {
+            accounts: {},
+            slots: {},
+            transactions: {},
+            transactionsStatus: {},
+            entry: {},
+            blocks: {},
+            blocksMeta: {},
+            commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
+            accountsDataSlice: [],
+            ping: { id: 1 },
+        };
+    }
+    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: {
+                client: {
+                    accountInclude: filter.account_include,
+                    accountExclude: filter.account_exclude,
+                    accountRequired: filter.account_required,
+                    vote: filter.vote,
+                    failed: filter.failed,
+                    signature: filter.signature,
+                },
+            },
+            accounts: {},
+            slots: {},
+            transactionsStatus: {},
+            entry: {},
+            blocks: {},
+            blocksMeta: {},
+            commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
+            accountsDataSlice: [],
+            ping: undefined,
+        };
+    }
+    /** 订阅交易 */
+    async subscribeTransactions(filter, callbacks) {
+        const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        let isCancelled = false;
+        const streamHolder = { current: null };
+        const cancel = () => {
+            isCancelled = true;
+            streamHolder.current?.end();
+            streamHolder.current = null;
+        };
+        this.subscribers.set(id, { filter, callbacks, cancel });
+        (async () => {
+            const autoReconnect = callbacks.autoReconnect !== false;
+            const maxBackoffMs = 60_000;
+            let backoffMs = this.config.retry_delay_ms;
+            try {
+                while (!isCancelled) {
+                    try {
+                        const stream = await this.client.subscribe();
+                        streamHolder.current = stream;
+                        await new Promise((resolve, reject) => {
+                            stream.write(this.initialSubscribeRequest(filter), (err) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                        backoffMs = this.config.retry_delay_ms;
+                        await new Promise((resolve, reject) => {
+                            const cleanup = () => {
+                                stream.removeAllListeners();
+                                if (streamHolder.current === stream) {
+                                    streamHolder.current = null;
+                                }
+                            };
+                            stream.on("data", (update) => {
+                                if (isCancelled)
+                                    return;
+                                if (update.ping) {
+                                    stream.write(this.subscribePingPongRequest(), (werr) => {
+                                        if (werr && callbacks.onError && !isCancelled) {
+                                            callbacks.onError(werr instanceof Error ? werr : new Error(String(werr)));
+                                        }
+                                    });
+                                    return;
+                                }
+                                if (!callbacks.onUpdate)
+                                    return;
+                                try {
+                                    const converted = this.convertUpdate(update);
+                                    callbacks.onUpdate(converted);
+                                }
+                                catch (err) {
+                                    const e = err instanceof Error ? err : new Error(String(err));
+                                    callbacks.onError?.(e);
+                                }
+                            });
+                            stream.on("error", (err) => {
+                                cleanup();
+                                reject(err);
+                            });
+                            stream.on("end", () => {
+                                cleanup();
+                                resolve();
+                            });
+                        });
+                    }
+                    catch (err) {
+                        if (isCancelled)
+                            break;
+                        const e = err instanceof Error ? err : new Error(String(err));
+                        callbacks.onError?.(e);
+                        if (!autoReconnect)
+                            break;
+                        await new Promise((r) => setTimeout(r, backoffMs));
+                        backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                        continue;
+                    }
+                    if (isCancelled)
+                        break;
+                    if (!autoReconnect) {
+                        callbacks.onEnd?.();
+                        break;
+                    }
+                    await new Promise((r) => setTimeout(r, backoffMs));
+                    backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
+                }
+            }
+            finally {
+                streamHolder.current?.end();
+                streamHolder.current = null;
+                this.subscribers.delete(id);
+            }
+        })();
+        return {
+            id,
+            cancel: () => {
+                cancel();
+                this.subscribers.delete(id);
+            },
+        };
+    }
+    /**
+     * 订阅并直接产出 `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);
+        if (sub) {
+            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) {
+        const resp = await this.client.getLatestBlockhash(commitment);
+        return {
+            slot: Number(resp.slot),
+            blockhash: resp.blockhash,
+            lastValidBlockHeight: Number(resp.lastValidBlockHeight),
+        };
+    }
+    /** 获取区块高度 */
+    async getBlockHeight(commitment) {
+        const resp = await this.client.getBlockHeight(commitment);
+        return Number(resp);
+    }
+    /** 获取当前 Slot */
+    async getSlot(commitment) {
+        const resp = await this.client.getSlot(commitment);
+        return Number(resp);
+    }
+    /** 获取服务器版本 */
+    async getVersion() {
+        const resp = await this.client.getVersion();
+        return String(resp);
+    }
+    /** 验证区块哈希是否有效 */
+    async isBlockhashValid(blockhash, commitment) {
+        const resp = await this.client.isBlockhashValid(blockhash, commitment);
+        return {
+            slot: Number(resp.slot),
+            valid: resp.valid,
+        };
+    }
+    /** 发送 Ping 请求 */
+    async ping(count) {
+        const resp = await this.client.ping(count);
+        return Number(resp);
+    }
+}
+exports.YellowstoneGrpc = YellowstoneGrpc;

package/dist/grpc/client_stub.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 此文件保留以兼容旧引用，实际实现已移至 client.ts
+ */
+export type { SubscribeCallbacks } from "./client.js";
+export { YellowstoneGrpc } from "./client.js";

package/dist/grpc/client_stub.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YellowstoneGrpc = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "YellowstoneGrpc", { enumerable: true, get: function () { return client_js_1.YellowstoneGrpc; } });

package/dist/grpc/event_parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 与 Rust `grpc::event_parser`（`pub use crate::core as event_parser`）对应：核心解析子集再导出。
+ */
+export { parseTransactionEvents, parseLogsOnly, parseTransactionWithListener, parseTransactionEventsStreaming, parseLogsStreaming, parseTransactionWithStreamingListener, parseLog, nowUs, type EventListener, type StreamingEventListener, } from "../core/unified_parser.js";
+export type { DexEvent } from "../core/dex_event.js";
+export type { EventMetadata } from "../core/metadata.js";

package/dist/grpc/event_parser.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowUs = exports.parseLog = exports.parseTransactionWithStreamingListener = exports.parseLogsStreaming = exports.parseTransactionEventsStreaming = exports.parseTransactionWithListener = exports.parseLogsOnly = exports.parseTransactionEvents = void 0;
+/**
+ * 与 Rust `grpc::event_parser`（`pub use crate::core as event_parser`）对应：核心解析子集再导出。
+ */
+var unified_parser_js_1 = require("../core/unified_parser.js");
+Object.defineProperty(exports, "parseTransactionEvents", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionEvents; } });
+Object.defineProperty(exports, "parseLogsOnly", { enumerable: true, get: function () { return unified_parser_js_1.parseLogsOnly; } });
+Object.defineProperty(exports, "parseTransactionWithListener", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionWithListener; } });
+Object.defineProperty(exports, "parseTransactionEventsStreaming", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionEventsStreaming; } });
+Object.defineProperty(exports, "parseLogsStreaming", { enumerable: true, get: function () { return unified_parser_js_1.parseLogsStreaming; } });
+Object.defineProperty(exports, "parseTransactionWithStreamingListener", { enumerable: true, get: function () { return unified_parser_js_1.parseTransactionWithStreamingListener; } });
+Object.defineProperty(exports, "parseLog", { enumerable: true, get: function () { return unified_parser_js_1.parseLog; } });
+Object.defineProperty(exports, "nowUs", { enumerable: true, get: function () { return unified_parser_js_1.nowUs; } });