sol-parser-sdk-nodejs 0.4.0 → 0.4.4

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[];

package/dist/grpc/log_instr_dedup.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedupeLogInstructionEvents = dedupeLogInstructionEvents;
+const dex_event_js_1 = require("../core/dex_event.js");
+const ZERO = (0, dex_event_js_1.defaultPubkey)();
+const PUMPFUN_TRADE_NAMES = new Set([
+    "PumpFunTrade",
+    "PumpFunBuy",
+    "PumpFunSell",
+    "PumpFunBuyExactSolIn",
+]);
+function eventName(ev) {
+    return Object.keys(ev)[0] ?? "";
+}
+function payload(ev) {
+    const key = eventName(ev);
+    return key ? ev[key] : null;
+}
+function isDefaultPubkey(v) {
+    return v === "" || v === ZERO || v == null;
+}
+function fillString(to, key, from) {
+    const value = from[key];
+    if (isDefaultPubkey(to[key]) && !isDefaultPubkey(value)) {
+        to[key] = value;
+    }
+}
+function fillNestedString(to, parent, key, from) {
+    const srcParent = from[parent];
+    if (!srcParent || typeof srcParent !== "object")
+        return;
+    if (!to[parent] || typeof to[parent] !== "object")
+        to[parent] = {};
+    fillString(to[parent], key, srcParent);
+}
+function fillIxName(to, from) {
+    if ((to.ix_name ?? "") === "" && (from.ix_name ?? "") !== "") {
+        to.ix_name = from.ix_name;
+    }
+}
+function ixLane(ixName) {
+    switch (ixName) {
+        case "sell":
+            return 1;
+        case "buy_exact_sol_in":
+            return 2;
+        default:
+            return 0;
+    }
+}
+function nextOccurrence(base, counts) {
+    const current = counts.get(base) ?? 0;
+    counts.set(base, current + 1);
+    return current;
+}
+function dedupeKey(ev, pumpfunLaneCounts) {
+    const name = eventName(ev);
+    const data = payload(ev);
+    if (!data)
+        return null;
+    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);
+        return `PumpFunTrade|${base}|${occurrence}`;
+    }
+    switch (name) {
+        case "PumpFunCreate":
+            return `PumpFunCreate|${data.mint}`;
+        case "PumpFunCreateV2":
+            return `PumpFunCreateV2|${data.mint}`;
+        case "PumpFunMigrate":
+            return `PumpFunMigrate|${data.mint}|${data.pool}|${data.user}`;
+        case "BonkTrade":
+            return `BonkTrade|${data.pool_state}|${data.user}|${Boolean(data.is_buy)}`;
+        case "BonkPoolCreate":
+            return `BonkPoolCreate|${data.pool_state}`;
+        case "BonkMigrateAmm":
+            return `BonkMigrateAmm|${data.old_pool}|${data.new_pool}|${data.user}`;
+        case "PumpSwapTrade":
+            return `PumpSwapTrade|${data.mint}|${data.user}|${Boolean(data.is_buy)}|${ixLane(data.ix_name)}`;
+        case "PumpSwapBuy":
+            return `PumpSwapBuy|${data.pool}|${data.user}`;
+        case "PumpSwapSell":
+            return `PumpSwapSell|${data.pool}|${data.user}`;
+        case "PumpSwapCreatePool":
+            return `PumpSwapCreatePool|${data.pool}|${data.base_mint}|${data.quote_mint}`;
+        case "PumpSwapLiquidityAdded":
+            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)}`;
+        default:
+            return null;
+    }
+}
+function mergePumpfunTrade(log, ix) {
+    for (const key of [
+        "bonding_curve",
+        "associated_bonding_curve",
+        "token_program",
+        "creator_vault",
+        "fee_recipient",
+        "creator",
+    ]) {
+        fillString(log, key, ix);
+    }
+    if (log.account == null && ix.account != null)
+        log.account = ix.account;
+    fillIxName(log, ix);
+    log.is_created_buy = Boolean(log.is_created_buy) || Boolean(ix.is_created_buy);
+}
+function mergePumpfunCreate(log, ix) {
+    for (const key of [
+        "name",
+        "symbol",
+        "uri",
+        "bonding_curve",
+        "user",
+        "creator",
+        "token_program",
+    ]) {
+        fillString(log, key, ix);
+    }
+}
+function mergePumpfunCreateV2(log, ix) {
+    mergePumpfunCreate(log, ix);
+    for (const key of [
+        "mint_authority",
+        "associated_bonding_curve",
+        "global",
+        "system_program",
+        "associated_token_program",
+        "mayhem_program_id",
+        "global_params",
+        "sol_vault",
+        "mayhem_state",
+        "mayhem_token_vault",
+        "event_authority",
+        "program",
+        "observed_fee_recipient",
+    ]) {
+        fillString(log, key, ix);
+    }
+}
+function mergePumpfunMigrate(log, ix) {
+    for (const key of ["bonding_curve", "pool", "user"]) {
+        fillString(log, key, ix);
+    }
+}
+function mergePumpSwapBuySell(log, ix, includeIxName) {
+    for (const key of [
+        "user_base_token_account",
+        "user_quote_token_account",
+        "protocol_fee_recipient",
+        "protocol_fee_recipient_token_account",
+        "coin_creator",
+        "base_mint",
+        "quote_mint",
+        "pool_base_token_account",
+        "pool_quote_token_account",
+        "coin_creator_vault_ata",
+        "coin_creator_vault_authority",
+        "base_token_program",
+        "quote_token_program",
+    ]) {
+        fillString(log, key, ix);
+    }
+    if (includeIxName)
+        fillIxName(log, ix);
+}
+function mergePumpSwapCreatePool(log, ix) {
+    for (const key of [
+        "creator",
+        "pool",
+        "lp_mint",
+        "user_base_token_account",
+        "user_quote_token_account",
+        "coin_creator",
+    ]) {
+        fillString(log, key, ix);
+    }
+}
+function mergePumpSwapLiquidity(log, ix) {
+    for (const key of [
+        "user_base_token_account",
+        "user_quote_token_account",
+        "user_pool_token_account",
+    ]) {
+        fillString(log, key, ix);
+    }
+}
+function mergeRaydiumClmmSwap(log, ix) {
+    for (const key of ["token_account_0", "token_account_1", "sender"]) {
+        fillString(log, key, ix);
+    }
+}
+function mergeRaydiumAmmV4Swap(log, ix) {
+    for (const key of [
+        "token_program",
+        "amm_authority",
+        "amm_open_orders",
+        "amm_target_orders",
+        "pool_coin_token_account",
+        "pool_pc_token_account",
+        "serum_program",
+        "serum_market",
+        "serum_bids",
+        "serum_asks",
+        "serum_event_queue",
+        "serum_coin_vault_account",
+        "serum_pc_vault_account",
+        "serum_vault_signer",
+        "user_source_token_account",
+        "user_destination_token_account",
+    ]) {
+        fillString(log, key, ix);
+    }
+}
+function mergeBonkPoolCreate(log, ix) {
+    fillString(log, "creator", ix);
+    for (const key of ["name", "symbol", "uri"]) {
+        fillNestedString(log, "base_mint_param", key, ix);
+    }
+}
+function mergeBonkMigrateAmm(log, ix) {
+    for (const key of ["old_pool", "new_pool", "user"]) {
+        fillString(log, key, ix);
+    }
+}
+function mergeGrpcInstructionIntoLog(logEvent, ixEvent) {
+    const logName = eventName(logEvent);
+    const ixName = eventName(ixEvent);
+    const log = payload(logEvent);
+    const ix = payload(ixEvent);
+    if (!log || !ix)
+        return;
+    if (PUMPFUN_TRADE_NAMES.has(logName) && PUMPFUN_TRADE_NAMES.has(ixName)) {
+        mergePumpfunTrade(log, ix);
+        return;
+    }
+    switch (logName) {
+        case "PumpFunCreate":
+            if (ixName === "PumpFunCreate")
+                mergePumpfunCreate(log, ix);
+            break;
+        case "PumpFunCreateV2":
+            if (ixName === "PumpFunCreateV2")
+                mergePumpfunCreateV2(log, ix);
+            break;
+        case "PumpFunMigrate":
+            if (ixName === "PumpFunMigrate")
+                mergePumpfunMigrate(log, ix);
+            break;
+        case "PumpSwapTrade":
+            if (ixName === "PumpSwapTrade")
+                fillIxName(log, ix);
+            break;
+        case "PumpSwapBuy":
+            if (ixName === "PumpSwapBuy")
+                mergePumpSwapBuySell(log, ix, true);
+            break;
+        case "PumpSwapSell":
+            if (ixName === "PumpSwapSell")
+                mergePumpSwapBuySell(log, ix, false);
+            break;
+        case "PumpSwapCreatePool":
+            if (ixName === "PumpSwapCreatePool")
+                mergePumpSwapCreatePool(log, ix);
+            break;
+        case "PumpSwapLiquidityAdded":
+            if (ixName === "PumpSwapLiquidityAdded")
+                mergePumpSwapLiquidity(log, ix);
+            break;
+        case "PumpSwapLiquidityRemoved":
+            if (ixName === "PumpSwapLiquidityRemoved")
+                mergePumpSwapLiquidity(log, ix);
+            break;
+        case "RaydiumClmmSwap":
+            if (ixName === "RaydiumClmmSwap")
+                mergeRaydiumClmmSwap(log, ix);
+            break;
+        case "RaydiumAmmV4Swap":
+            if (ixName === "RaydiumAmmV4Swap")
+                mergeRaydiumAmmV4Swap(log, ix);
+            break;
+        case "BonkPoolCreate":
+            if (ixName === "BonkPoolCreate")
+                mergeBonkPoolCreate(log, ix);
+            break;
+        case "BonkMigrateAmm":
+            if (ixName === "BonkMigrateAmm")
+                mergeBonkMigrateAmm(log, ix);
+            break;
+        default:
+            break;
+    }
+}
+function dedupeLogInstructionEvents(logEvents, instructionEvents) {
+    const out = [];
+    const indexByKey = new Map();
+    const logPumpfunLaneCounts = new Map();
+    const ixPumpfunLaneCounts = new Map();
+    for (const ev of logEvents) {
+        const key = dedupeKey(ev, logPumpfunLaneCounts);
+        if (key)
+            indexByKey.set(key, out.length);
+        out.push(ev);
+    }
+    for (const ev of instructionEvents) {
+        const key = dedupeKey(ev, ixPumpfunLaneCounts);
+        if (!key) {
+            out.push(ev);
+            continue;
+        }
+        const existing = indexByKey.get(key);
+        if (existing === undefined) {
+            indexByKey.set(key, out.length);
+            out.push(ev);
+            continue;
+        }
+        mergeGrpcInstructionIntoLog(out[existing], ev);
+    }
+    return out;
+}

package/dist/grpc/order_buffer.d.ts

@@ -0,0 +1,27 @@
+import type { DexEvent } from "../core/dex_event.js";
+import type { ClientConfig } from "./types.js";
+export declare class OrderDispatcher {
+    private readonly mode;
+    private readonly timeoutMs;
+    private readonly microBatchUs;
+    private readonly slots;
+    private readonly streamingWatermarks;
+    private microBatch;
+    private microBatchStartUs;
+    private lastFlushMs;
+    private currentSlot;
+    private seq;
+    constructor(config: ClientConfig);
+    get needsTimer(): boolean;
+    pushTransactionEvents(events: DexEvent[], fallbackSlot: number, fallbackTxIndex: number, emit: (event: DexEvent) => void): void;
+    flushDue(emit: (event: DexEvent) => void): void;
+    flushAll(emit: (event: DexEvent) => void): void;
+    private pushOrdered;
+    private pushStreaming;
+    private pushMicroBatch;
+    private pushSlotBatch;
+    private flushBefore;
+    private flushAllSlots;
+    private flushMicroBatch;
+    private emitBatch;
+}