sol-parser-sdk 0.5.9

package/dist/grpc/geyser_connect.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 与 Rust `sol-parser-sdk/src/grpc/geyser_connect.rs` 对齐：Yellowstone Geyser gRPC 连接选项。
+ *
+ * `@triton-one/yellowstone-grpc` 的 `Client` 通过构造函数第三参传入 `ChannelOptions`；
+ * `connectTimeoutMs` 无与 tonic 完全一一对应的项，仅作文档与默认值对齐（可配合环境网络调优）。
+ */
+import type { ChannelOptions } from "@grpc/grpc-js";
+import Client from "@triton-one/yellowstone-grpc";
+/** 与 Rust `GeyserConnectConfig` 字段对应（毫秒 / 字节） */
+export interface GeyserConnectConfig {
+    /** 对应 Rust `connect_timeout`（毫秒） */
+    connectTimeoutMs: number;
+    /** 对应 Rust `max_decoding_message_size` */
+    maxDecodingMessageSize: number;
+    /** 对应 Rust `x_token` */
+    xToken?: string;
+    /** gRPC 通道 HTTP/2 keepalive 间隔（毫秒），与 Rust `ClientConfig.keep_alive_interval_ms` 默认对齐 */
+    keepAliveIntervalMs?: number;
+    /** gRPC keepalive 应答超时（毫秒） */
+    keepAliveTimeoutMs?: number;
+}
+/** 与 Rust `GeyserConnectConfig::default` 一致 */
+export declare function defaultGeyserConnectConfig(): GeyserConnectConfig;
+/** 与 `ClientConfig` / `grpc.keepalive_*` 对齐，用于长连接抗 NAT/负载均衡 idle 断开 */
+export declare function geyserGrpcChannelOptions(config?: GeyserConnectConfig): ChannelOptions;
+/**
+ * 建立 Yellowstone Geyser 客户端（与 Rust `connect_yellowstone_geyser` 一致）。
+ * Rust 为 async；此处构造同步完成，返回 `Promise` 以保持 `await connectYellowstoneGeyser(...)` 写法。
+ */
+export declare function connectYellowstoneGeyser(endpoint: string, config?: GeyserConnectConfig): Promise<Client>;

package/dist/grpc/geyser_connect.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultGeyserConnectConfig = defaultGeyserConnectConfig;
+exports.geyserGrpcChannelOptions = geyserGrpcChannelOptions;
+exports.connectYellowstoneGeyser = connectYellowstoneGeyser;
+const yellowstone_grpc_1 = __importDefault(require("@triton-one/yellowstone-grpc"));
+/** 与 Rust `GeyserConnectConfig::default` 一致 */
+function defaultGeyserConnectConfig() {
+    return {
+        connectTimeoutMs: 8000,
+        maxDecodingMessageSize: 1024 * 1024 * 1024,
+        xToken: undefined,
+        keepAliveIntervalMs: 30_000,
+        keepAliveTimeoutMs: 5000,
+    };
+}
+/** 与 `ClientConfig` / `grpc.keepalive_*` 对齐，用于长连接抗 NAT/负载均衡 idle 断开 */
+function geyserGrpcChannelOptions(config = defaultGeyserConnectConfig()) {
+    const max = config.maxDecodingMessageSize;
+    const interval = config.keepAliveIntervalMs ?? 30_000;
+    const timeout = config.keepAliveTimeoutMs ?? 5000;
+    return {
+        "grpc.max_receive_message_length": max,
+        "grpc.max_send_message_length": max,
+        "grpc.keepalive_time_ms": interval,
+        "grpc.keepalive_timeout_ms": timeout,
+        /** 无活跃 RPC 时仍发 keepalive，避免长时间仅订阅时被中间设备掐断 */
+        "grpc.keepalive_permit_without_calls": 1,
+    };
+}
+/**
+ * 建立 Yellowstone Geyser 客户端（与 Rust `connect_yellowstone_geyser` 一致）。
+ * Rust 为 async；此处构造同步完成，返回 `Promise` 以保持 `await connectYellowstoneGeyser(...)` 写法。
+ */
+async function connectYellowstoneGeyser(endpoint, config = defaultGeyserConnectConfig()) {
+    return new yellowstone_grpc_1.default(endpoint, config.xToken, geyserGrpcChannelOptions(config));
+}

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,402 @@
+"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 fillNonZero(to, key, from) {
+    const value = from[key];
+    if ((to[key] == null || to[key] === 0n || to[key] === 0) && value != null && value !== 0n && value !== 0) {
+        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":
+        case "sell_v2":
+            return 1;
+        case "buy_exact_sol_in":
+        case "buy_exact_quote_in":
+        case "buy_exact_quote_in_v2":
+            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 `PumpFunCreate|${data.mint}`;
+        case "PumpFunMigrate":
+            return `PumpFunMigrate|${data.mint}|${data.pool}|${data.user}`;
+        case "RaydiumLaunchlabTrade":
+            return `RaydiumLaunchlabTrade|${data.pool_state}|${data.user}|${Boolean(data.is_buy)}`;
+        case "RaydiumLaunchlabPoolCreate":
+            return `RaydiumLaunchlabPoolCreate|${data.pool_state}`;
+        case "RaydiumLaunchlabMigrateAmm":
+            return `RaydiumLaunchlabMigrateAmm|${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",
+        "bonding_curve_v2",
+        "associated_bonding_curve",
+        "associated_user",
+        "system_program",
+        "token_program",
+        "quote_token_program",
+        "associated_token_program",
+        "creator_vault",
+        "fee_recipient",
+        "associated_quote_fee_recipient",
+        "buyback_fee_recipient",
+        "associated_quote_buyback_fee_recipient",
+        "associated_quote_bonding_curve",
+        "associated_quote_user",
+        "associated_creator_vault",
+        "sharing_config",
+        "event_authority",
+        "program",
+        "global_volume_accumulator",
+        "user_volume_accumulator",
+        "associated_user_volume_accumulator",
+        "fee_config",
+        "fee_program",
+        "global",
+        "quote_mint",
+        "creator",
+    ]) {
+        fillString(log, key, ix);
+    }
+    if (log.account == null && ix.account != null)
+        log.account = ix.account;
+    for (const key of [
+        "amount",
+        "max_sol_cost",
+        "min_sol_output",
+        "spendable_sol_in",
+        "spendable_quote_in",
+        "min_tokens_out",
+        "quote_amount",
+        "virtual_quote_reserves",
+        "real_quote_reserves",
+    ]) {
+        fillNonZero(log, key, ix);
+    }
+    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",
+        "mint",
+        "bonding_curve",
+        "user",
+        "creator",
+        "token_program",
+        "quote_mint",
+        "quote_vault",
+        "quote_token_program",
+    ]) {
+        fillString(log, key, ix);
+    }
+    for (const key of [
+        "timestamp",
+        "virtual_token_reserves",
+        "virtual_sol_reserves",
+        "real_token_reserves",
+        "token_total_supply",
+        "virtual_quote_reserves",
+    ]) {
+        fillNonZero(log, key, ix);
+    }
+    fillIxName(log, ix);
+    log.is_mayhem_mode = Boolean(log.is_mayhem_mode) || Boolean(ix.is_mayhem_mode);
+    log.is_cashback_enabled =
+        Boolean(log.is_cashback_enabled) || Boolean(ix.is_cashback_enabled);
+}
+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",
+        "pool_v2",
+        "fee_recipient",
+        "fee_recipient_quote_token_account",
+    ]) {
+        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 mergeRaydiumLaunchlabPoolCreate(log, ix) {
+    fillString(log, "creator", ix);
+    for (const key of ["name", "symbol", "uri"]) {
+        fillNestedString(log, "base_mint_param", key, ix);
+    }
+}
+function mergeRaydiumLaunchlabMigrateAmm(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;
+    }
+    if (logName === "PumpFunCreate" && ixName === "PumpFunCreateV2") {
+        mergePumpfunCreate(log, ix);
+        return;
+    }
+    if (logName === "PumpFunCreateV2" && ixName === "PumpFunCreate") {
+        mergePumpfunCreateV2(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 "RaydiumLaunchlabPoolCreate":
+            if (ixName === "RaydiumLaunchlabPoolCreate")
+                mergeRaydiumLaunchlabPoolCreate(log, ix);
+            break;
+        case "RaydiumLaunchlabMigrateAmm":
+            if (ixName === "RaydiumLaunchlabMigrateAmm")
+                mergeRaydiumLaunchlabMigrateAmm(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;
+}

package/dist/grpc/order_buffer.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderDispatcher = void 0;
+const dex_event_js_1 = require("../core/dex_event.js");
+function eventSlotAndIndex(events, fallbackSlot, fallbackTxIndex) {
+    const meta = events.length > 0 ? (0, dex_event_js_1.metadataForDexEvent)(events[0]) : null;
+    return {
+        slot: Number.isFinite(meta?.slot) ? meta.slot : fallbackSlot,
+        txIndex: Number.isFinite(meta?.tx_index) ? meta.tx_index : fallbackTxIndex,
+    };
+}
+class OrderDispatcher {
+    mode;
+    timeoutMs;
+    microBatchUs;
+    slots = new Map();
+    streamingWatermarks = new Map();
+    microBatch = [];
+    microBatchStartUs = 0;
+    lastFlushMs = Date.now();
+    currentSlot = 0;
+    seq = 0;
+    constructor(config) {
+        this.mode = config.order_mode;
+        this.timeoutMs = Math.max(1, config.order_timeout_ms || 100);
+        this.microBatchUs = Math.max(1, config.micro_batch_us || 100);
+    }
+    get needsTimer() {
+        return this.mode !== "Unordered";
+    }
+    pushTransactionEvents(events, fallbackSlot, fallbackTxIndex, emit) {
+        if (events.length === 0)
+            return;
+        const { slot, txIndex } = eventSlotAndIndex(events, fallbackSlot, fallbackTxIndex);
+        const batch = { slot, txIndex, seq: this.seq++, events };
+        switch (this.mode) {
+            case "Unordered":
+                this.emitBatch(batch, emit);
+                return;
+            case "Ordered":
+                this.pushOrdered(batch, emit);
+                return;
+            case "StreamingOrdered":
+                this.pushStreaming(batch, emit);
+                return;
+            case "MicroBatch":
+                this.pushMicroBatch(batch, emit);
+                return;
+        }
+    }
+    flushDue(emit) {
+        const nowMs = Date.now();
+        if ((this.mode === "Ordered" || this.mode === "StreamingOrdered") && nowMs - this.lastFlushMs > this.timeoutMs) {
+            this.flushAllSlots(emit);
+        }
+        if (this.mode === "MicroBatch") {
+            const nowUs = Math.floor(nowMs * 1000);
+            if (this.microBatch.length > 0 && nowUs - this.microBatchStartUs >= this.microBatchUs) {
+                this.flushMicroBatch(emit);
+            }
+        }
+    }
+    flushAll(emit) {
+        this.flushAllSlots(emit);
+        this.flushMicroBatch(emit);
+    }
+    pushOrdered(batch, emit) {
+        if (batch.slot > this.currentSlot && this.currentSlot > 0) {
+            this.flushBefore(batch.slot, emit);
+        }
+        if (batch.slot > this.currentSlot)
+            this.currentSlot = batch.slot;
+        this.pushSlotBatch(batch);
+    }
+    pushStreaming(batch, emit) {
+        if (batch.slot > this.currentSlot && this.currentSlot > 0) {
+            this.flushBefore(batch.slot, emit);
+            for (const slot of [...this.streamingWatermarks.keys()]) {
+                if (slot < batch.slot)
+                    this.streamingWatermarks.delete(slot);
+            }
+        }
+        if (batch.slot > this.currentSlot)
+            this.currentSlot = batch.slot;
+        const expected = this.streamingWatermarks.get(batch.slot) ?? 0;
+        if (batch.txIndex === expected) {
+            this.emitBatch(batch, emit);
+            let watermark = expected + 1;
+            const buffered = this.slots.get(batch.slot);
+            if (buffered) {
+                buffered.sort(compareBatch);
+                let pos = buffered.findIndex((b) => b.txIndex === watermark);
+                while (pos >= 0) {
+                    const [next] = buffered.splice(pos, 1);
+                    this.emitBatch(next, emit);
+                    watermark += 1;
+                    pos = buffered.findIndex((b) => b.txIndex === watermark);
+                }
+                if (buffered.length === 0)
+                    this.slots.delete(batch.slot);
+            }
+            this.streamingWatermarks.set(batch.slot, watermark);
+        }
+        else if (batch.txIndex > expected) {
+            this.pushSlotBatch(batch);
+        }
+    }
+    pushMicroBatch(batch, emit) {
+        const nowUs = Math.floor(Date.now() * 1000);
+        if (this.microBatch.length === 0)
+            this.microBatchStartUs = nowUs;
+        this.microBatch.push(batch);
+        if (nowUs - this.microBatchStartUs >= this.microBatchUs) {
+            this.flushMicroBatch(emit);
+        }
+    }
+    pushSlotBatch(batch) {
+        const list = this.slots.get(batch.slot);
+        if (list)
+            list.push(batch);
+        else
+            this.slots.set(batch.slot, [batch]);
+    }
+    flushBefore(slot, emit) {
+        for (const s of [...this.slots.keys()].sort((a, b) => a - b)) {
+            if (s >= slot)
+                continue;
+            const batches = this.slots.get(s) ?? [];
+            batches.sort(compareBatch);
+            for (const batch of batches)
+                this.emitBatch(batch, emit);
+            this.slots.delete(s);
+            this.streamingWatermarks.delete(s);
+        }
+        this.lastFlushMs = Date.now();
+    }
+    flushAllSlots(emit) {
+        for (const s of [...this.slots.keys()].sort((a, b) => a - b)) {
+            const batches = this.slots.get(s) ?? [];
+            batches.sort(compareBatch);
+            for (const batch of batches)
+                this.emitBatch(batch, emit);
+            this.slots.delete(s);
+            this.streamingWatermarks.delete(s);
+        }
+        this.lastFlushMs = Date.now();
+    }
+    flushMicroBatch(emit) {
+        if (this.microBatch.length === 0)
+            return;
+        this.microBatch.sort(compareBatch);
+        for (const batch of this.microBatch)
+            this.emitBatch(batch, emit);
+        this.microBatch = [];
+        this.microBatchStartUs = 0;
+        this.lastFlushMs = Date.now();
+    }
+    emitBatch(batch, emit) {
+        for (const event of batch.events)
+            emit(event);
+    }
+}
+exports.OrderDispatcher = OrderDispatcher;
+function compareBatch(a, b) {
+    return a.slot - b.slot || a.txIndex - b.txIndex || a.seq - b.seq;
+}