sol-parser-sdk-nodejs 0.3.0

package/dist/grpc/client.js

@@ -0,0 +1,309 @@
+"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;
+    };
+})();
+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 types_js_1 = require("./types.js");
+/** Yellowstone gRPC 客户端包装器 */
+class YellowstoneGrpc {
+    client;
+    config;
+    connected = false;
+    subscribers = new Map();
+    constructor(endpoint, xToken, config = (0, types_js_1.defaultClientConfig)()) {
+        this.config = config;
+        this.client = new yellowstone_grpc_1.default(endpoint, xToken || undefined, undefined);
+    }
+    /** 连接到 gRPC 服务器 */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        this.connected = true;
+    }
+    /** 断开连接 */
+    async disconnect() {
+        for (const [, sub] of this.subscribers) {
+            sub.cancel();
+        }
+        this.subscribers.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,
+        };
+        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;
+    }
+    /** 订阅交易 */
+    async subscribeTransactions(filter, callbacks) {
+        const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        let isCancelled = false;
+        const cancel = () => {
+            isCancelled = true;
+        };
+        this.subscribers.set(id, { filter, callbacks, cancel });
+        (async () => {
+            try {
+                const stream = await this.client.subscribe();
+                await new Promise((resolve, reject) => {
+                    stream.write({
+                        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,
+                    }, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+                stream.on("data", (update) => {
+                    if (isCancelled)
+                        return;
+                    if (!callbacks.onUpdate)
+                        return;
+                    try {
+                        const converted = this.convertUpdate(update);
+                        callbacks.onUpdate(converted);
+                    }
+                    catch (err) {
+                        // 用户 onUpdate 内抛错（如同步 IO/画图）若未捕获，会破坏 gRPC duplex 流并触发 RST_STREAM。
+                        const e = err instanceof Error ? err : new Error(String(err));
+                        if (callbacks.onError) {
+                            callbacks.onError(e);
+                        }
+                    }
+                });
+                stream.on("error", (err) => {
+                    if (isCancelled)
+                        return;
+                    if (callbacks.onError) {
+                        callbacks.onError(err);
+                    }
+                });
+                stream.on("end", () => {
+                    if (isCancelled)
+                        return;
+                    this.subscribers.delete(id);
+                    if (callbacks.onEnd) {
+                        callbacks.onEnd();
+                    }
+                });
+                while (!isCancelled) {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                }
+                stream.end();
+            }
+            catch (err) {
+                if (isCancelled)
+                    return;
+                this.subscribers.delete(id);
+                if (callbacks.onError) {
+                    callbacks.onError(err);
+                }
+            }
+        })();
+        return {
+            id,
+            cancel: () => {
+                cancel();
+                this.subscribers.delete(id);
+            },
+        };
+    }
+    /** 取消订阅 */
+    unsubscribe(subId) {
+        const sub = this.subscribers.get(subId);
+        if (sub) {
+            sub.cancel();
+            this.subscribers.delete(subId);
+        }
+    }
+    /** 获取最新区块哈希 */
+    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/types.d.ts

@@ -0,0 +1,132 @@
+/** gRPC 订阅顺序模式 */
+export type OrderMode = "Unordered" | "Ordered" | "StreamingOrdered" | "MicroBatch";
+export type SlotStatus = "Processed" | "Confirmed" | "Finalized" | "FirstShredReceived" | "Completed" | "CreatedBank" | "Dead";
+export interface SubscribeUpdateAccountInfo {
+    pubkey: Uint8Array;
+    lamports: string | bigint;
+    owner: Uint8Array;
+    executable: boolean;
+    rentEpoch: string | bigint;
+    data: Uint8Array;
+    writeVersion: string | bigint;
+    txnSignature?: Uint8Array;
+}
+export interface SubscribeUpdateAccount {
+    slot: string | bigint;
+    isStartup: boolean;
+    account?: SubscribeUpdateAccountInfo;
+}
+export interface SubscribeUpdateSlot {
+    slot: string | bigint;
+    parent?: string | bigint;
+    status: SlotStatus;
+    deadError?: string;
+}
+export interface SubscribeUpdateTransactionInfo {
+    signature: Uint8Array;
+    isVote: boolean;
+    /** 原始 proto Transaction 对象 */
+    transactionRaw?: unknown;
+    /** 原始 proto TransactionStatusMeta 对象（含 logMessages） */
+    metaRaw?: {
+        logMessages?: string[];
+        logMessagesNone?: boolean;
+        err?: unknown;
+        preBalances?: string[];
+        postBalances?: string[];
+        [key: string]: unknown;
+    };
+    index: string | bigint;
+}
+export interface SubscribeUpdateTransaction {
+    slot: string | bigint;
+    transaction?: SubscribeUpdateTransactionInfo;
+}
+export interface SubscribeUpdateBlock {
+    slot: string | bigint;
+    blockhash: string;
+    parentSlot: string | bigint;
+    parentBlockhash: string;
+    executedTransactionCount: string | bigint;
+}
+export interface SubscribeUpdateBlockMeta {
+    slot: string | bigint;
+    blockhash: string;
+    parentSlot: string | bigint;
+    parentBlockhash: string;
+    executedTransactionCount: string | bigint;
+}
+export interface SubscribeUpdatePing {
+}
+export interface SubscribeUpdatePong {
+    id: number;
+}
+export interface SubscribeUpdate {
+    filters: string[];
+    account?: SubscribeUpdateAccount;
+    slot?: SubscribeUpdateSlot;
+    transaction?: SubscribeUpdateTransaction;
+    block?: SubscribeUpdateBlock;
+    blockMeta?: SubscribeUpdateBlockMeta;
+    ping?: SubscribeUpdatePing;
+    pong?: SubscribeUpdatePong;
+}
+export interface SubscribeCallbacks {
+    onUpdate?: (update: SubscribeUpdate) => void;
+    onError?: (err: Error) => void;
+    onEnd?: () => void;
+}
+export interface ClientConfig {
+    enable_metrics: boolean;
+    connection_timeout_ms: number;
+    request_timeout_ms: number;
+    enable_tls: boolean;
+    max_retries: number;
+    retry_delay_ms: number;
+    max_concurrent_streams: number;
+    keep_alive_interval_ms: number;
+    keep_alive_timeout_ms: number;
+    buffer_size: number;
+    order_mode: OrderMode;
+    order_timeout_ms: number;
+    micro_batch_us: number;
+}
+export declare function defaultClientConfig(): ClientConfig;
+export interface TransactionFilter {
+    account_include: string[];
+    account_exclude: string[];
+    account_required: string[];
+}
+export declare function newTransactionFilter(): TransactionFilter;
+/** 事件类型过滤标签 */
+export type EventType = "BlockMeta" | "PumpFunTrade" | "PumpFunBuy" | "PumpFunSell" | "PumpFunBuyExactSolIn" | "PumpFunCreate" | "PumpFunCreateV2" | "PumpFunComplete" | "PumpFunMigrate" | "PumpSwapTrade" | "PumpSwapBuy" | "PumpSwapSell" | "PumpSwapCreatePool" | "PumpSwapLiquidityAdded" | "PumpSwapLiquidityRemoved" | "RaydiumClmmSwap" | "RaydiumClmmIncreaseLiquidity" | "RaydiumClmmDecreaseLiquidity" | "RaydiumClmmCreatePool" | "RaydiumClmmOpenPosition" | "RaydiumClmmOpenPositionWithTokenExtNft" | "RaydiumClmmClosePosition" | "RaydiumClmmCollectFee" | "RaydiumCpmmSwap" | "RaydiumCpmmDeposit" | "RaydiumCpmmWithdraw" | "RaydiumCpmmInitialize" | "RaydiumAmmV4Swap" | "RaydiumAmmV4Deposit" | "RaydiumAmmV4Withdraw" | "RaydiumAmmV4WithdrawPnl" | "RaydiumAmmV4Initialize2" | "OrcaWhirlpoolSwap" | "OrcaWhirlpoolLiquidityIncreased" | "OrcaWhirlpoolLiquidityDecreased" | "OrcaWhirlpoolPoolInitialized" | "MeteoraPoolsSwap" | "MeteoraPoolsAddLiquidity" | "MeteoraPoolsRemoveLiquidity" | "MeteoraPoolsBootstrapLiquidity" | "MeteoraPoolsPoolCreated" | "MeteoraPoolsSetPoolFees" | "MeteoraDammV2Swap" | "MeteoraDammV2AddLiquidity" | "MeteoraDammV2RemoveLiquidity" | "MeteoraDammV2CreatePosition" | "MeteoraDammV2ClosePosition" | "MeteoraDammV2InitializePool" | "MeteoraDlmmSwap" | "MeteoraDlmmAddLiquidity" | "MeteoraDlmmRemoveLiquidity" | "MeteoraDlmmInitializePool" | "MeteoraDlmmInitializeBinArray" | "MeteoraDlmmCreatePosition" | "MeteoraDlmmClosePosition" | "MeteoraDlmmClaimFee" | "BonkTrade" | "BonkPoolCreate" | "BonkMigrateAmm" | "TokenAccount" | "TokenInfo" | "NonceAccount" | "AccountPumpSwapGlobalConfig" | "AccountPumpSwapPool";
+/** 所有事件类型列表 */
+export declare const ALL_EVENT_TYPES: EventType[];
+export interface EventTypeFilter {
+    include_only?: EventType[];
+    exclude_types?: EventType[];
+    shouldInclude(eventType: EventType): boolean;
+}
+export declare function eventTypeFilterIncludeOnly(types: EventType[]): EventTypeFilter;
+export declare function eventTypeFilterExclude(types: EventType[]): EventTypeFilter;
+/** 过滤器是否包含 PumpFun 相关类型 */
+export declare function eventTypeFilterIncludesPumpfun(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 PumpSwap 相关类型 */
+export declare function eventTypeFilterIncludesPumpswap(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 Meteora DAMM V2 相关类型 */
+export declare function eventTypeFilterIncludesMeteoraDammV2(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 Raydium CLMM 相关类型 */
+export declare function eventTypeFilterIncludesRaydiumClmm(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 Raydium CPMM 相关类型 */
+export declare function eventTypeFilterIncludesRaydiumCpmm(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 Raydium AMM V4 相关类型 */
+export declare function eventTypeFilterIncludesRaydiumAmmV4(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 Orca Whirlpool 相关类型 */
+export declare function eventTypeFilterIncludesOrcaWhirlpool(filter: EventTypeFilter): boolean;
+/** 过滤器是否包含 Bonk Launchpad 相关类型 */
+export declare function eventTypeFilterIncludesBonk(filter: EventTypeFilter): boolean;
+/**
+ * `parseInstructionUnified` 前置白名单：仅当 `include_only` 与下列指令相关类型有交集时才解析指令。
+ * 若白名单中不含下列任一类型，则整条指令解析入口返回 null。
+ */
+export declare function eventTypeFilterAllowsInstructionParsing(includeOnly: EventType[]): boolean;