sol-parser-sdk-nodejs 0.4.0 → 0.5.5

package/dist/grpc/log_instr_dedup.js

@@ -0,0 +1,378 @@
+"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 `PumpFunCreateV2|${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",
+        "bonding_curve",
+        "user",
+        "creator",
+        "token_program",
+        "quote_mint",
+    ]) {
+        fillString(log, key, ix);
+    }
+    fillNonZero(log, "virtual_quote_reserves", 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",
+        "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;
+    }
+    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;
+}

package/dist/grpc/program_ids.d.ts

@@ -6,15 +6,17 @@ import type { AccountFilter, TransactionFilter } from "./types.js";
 export declare const PUMPFUN_PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
 export declare const PUMPSWAP_PROGRAM_ID = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
 export declare const PUMPSWAP_FEES_PROGRAM_ID = "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ";
-/** 与 Rust `BONK_PROGRAM_ID`（`Protocol::Bonk`）一致 */
-export declare const BONK_PROGRAM_ID = "BSwp6bEBihVLdqJRKS58NaebUBSDNjN7MdpFwNaR6gn3";
+export declare const PUMP_FEES_PROGRAM_ID = "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ";
+/** Raydium LaunchLab program id. */
+export declare const RAYDIUM_LAUNCHLAB_PROGRAM_ID = "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj";
 export declare const RAYDIUM_CPMM_PROGRAM_ID = "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C";
-export declare const RAYDIUM_CLMM_PROGRAM_ID = "CAMMCzo5YL8w4VFF8KVHrK22GGUQtcaMpgYqJPXBDvfE";
+export declare const RAYDIUM_CLMM_PROGRAM_ID = "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK";
 export declare const RAYDIUM_AMM_V4_PROGRAM_ID = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8";
 export declare const ORCA_WHIRLPOOL_PROGRAM_ID = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc";
 export declare const METEORA_POOLS_PROGRAM_ID = "Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB";
 export declare const METEORA_DAMM_V2_PROGRAM_ID = "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG";
 export declare const METEORA_DLMM_PROGRAM_ID = "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo";
+export declare const METEORA_DBC_PROGRAM_ID = "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN";
 /** 与 Rust `PROTOCOL_PROGRAM_IDS` 一致（仅含 Rust 中存在的协议） */
 export declare const PROTOCOL_PROGRAM_IDS: Record<Protocol, readonly string[]>;
 /** 与 Rust `get_program_ids_for_protocols` 一致 */

package/dist/grpc/program_ids.js

@@ -1,30 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROTOCOL_PROGRAM_IDS = exports.METEORA_DLMM_PROGRAM_ID = exports.METEORA_DAMM_V2_PROGRAM_ID = exports.METEORA_POOLS_PROGRAM_ID = exports.ORCA_WHIRLPOOL_PROGRAM_ID = exports.RAYDIUM_AMM_V4_PROGRAM_ID = exports.RAYDIUM_CLMM_PROGRAM_ID = exports.RAYDIUM_CPMM_PROGRAM_ID = exports.BONK_PROGRAM_ID = exports.PUMPSWAP_FEES_PROGRAM_ID = exports.PUMPSWAP_PROGRAM_ID = exports.PUMPFUN_PROGRAM_ID = void 0;
+exports.PROTOCOL_PROGRAM_IDS = exports.METEORA_DBC_PROGRAM_ID = exports.METEORA_DLMM_PROGRAM_ID = exports.METEORA_DAMM_V2_PROGRAM_ID = exports.METEORA_POOLS_PROGRAM_ID = exports.ORCA_WHIRLPOOL_PROGRAM_ID = exports.RAYDIUM_AMM_V4_PROGRAM_ID = exports.RAYDIUM_CLMM_PROGRAM_ID = exports.RAYDIUM_CPMM_PROGRAM_ID = exports.RAYDIUM_LAUNCHLAB_PROGRAM_ID = exports.PUMP_FEES_PROGRAM_ID = exports.PUMPSWAP_FEES_PROGRAM_ID = exports.PUMPSWAP_PROGRAM_ID = exports.PUMPFUN_PROGRAM_ID = void 0;
 exports.getProgramIdsForProtocols = getProgramIdsForProtocols;
 exports.transactionFilterForProtocols = transactionFilterForProtocols;
 exports.accountFilterForProtocols = accountFilterForProtocols;
 exports.PUMPFUN_PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
 exports.PUMPSWAP_PROGRAM_ID = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
 exports.PUMPSWAP_FEES_PROGRAM_ID = "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ";
-/** 与 Rust `BONK_PROGRAM_ID`（`Protocol::Bonk`）一致 */
-exports.BONK_PROGRAM_ID = "BSwp6bEBihVLdqJRKS58NaebUBSDNjN7MdpFwNaR6gn3";
+exports.PUMP_FEES_PROGRAM_ID = exports.PUMPSWAP_FEES_PROGRAM_ID;
+/** Raydium LaunchLab program id. */
+exports.RAYDIUM_LAUNCHLAB_PROGRAM_ID = "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj";
 exports.RAYDIUM_CPMM_PROGRAM_ID = "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C";
-exports.RAYDIUM_CLMM_PROGRAM_ID = "CAMMCzo5YL8w4VFF8KVHrK22GGUQtcaMpgYqJPXBDvfE";
+exports.RAYDIUM_CLMM_PROGRAM_ID = "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK";
 exports.RAYDIUM_AMM_V4_PROGRAM_ID = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8";
 exports.ORCA_WHIRLPOOL_PROGRAM_ID = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc";
 exports.METEORA_POOLS_PROGRAM_ID = "Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB";
 exports.METEORA_DAMM_V2_PROGRAM_ID = "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG";
 exports.METEORA_DLMM_PROGRAM_ID = "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo";
+exports.METEORA_DBC_PROGRAM_ID = "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN";
 /** 与 Rust `PROTOCOL_PROGRAM_IDS` 一致（仅含 Rust 中存在的协议） */
 exports.PROTOCOL_PROGRAM_IDS = {
     PumpFun: [exports.PUMPFUN_PROGRAM_ID],
     PumpSwap: [exports.PUMPSWAP_PROGRAM_ID],
-    Bonk: [exports.BONK_PROGRAM_ID],
+    PumpFees: [exports.PUMP_FEES_PROGRAM_ID],
+    RaydiumLaunchlab: [exports.RAYDIUM_LAUNCHLAB_PROGRAM_ID],
     RaydiumCpmm: [exports.RAYDIUM_CPMM_PROGRAM_ID],
     RaydiumClmm: [exports.RAYDIUM_CLMM_PROGRAM_ID],
     RaydiumAmmV4: [exports.RAYDIUM_AMM_V4_PROGRAM_ID],
+    OrcaWhirlpool: [exports.ORCA_WHIRLPOOL_PROGRAM_ID],
+    MeteoraPools: [exports.METEORA_POOLS_PROGRAM_ID],
     MeteoraDammV2: [exports.METEORA_DAMM_V2_PROGRAM_ID],
+    MeteoraDlmm: [exports.METEORA_DLMM_PROGRAM_ID],
+    MeteoraDbc: [exports.METEORA_DBC_PROGRAM_ID],
 };
 /** 与 Rust `get_program_ids_for_protocols` 一致 */
 function getProgramIdsForProtocols(protocols) {