sol-parser-sdk 0.5.14 → 0.5.16

package/dist/grpc/client.js

@@ -1,47 +1,17 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YellowstoneGrpc = void 0;
+const block_meta_js_1 = require("./block_meta.js");
 /**
- * Yellowstone gRPC 客户端实现 - 基于 @triton-one/yellowstone-grpc
+ * Yellowstone gRPC 客户端实现 - 基于纯 JavaScript @grpc/grpc-js
  */
-const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
+const native_client_js_1 = __importDefault(require("./native_client.js"));
+const geyser_js_1 = require("./protocol/geyser.js");
 const bs58_1 = __importDefault(require("bs58"));
+const node_crypto_1 = require("node:crypto");
 const node_buffer_1 = require("node:buffer");
 const dex_event_js_1 = require("../core/dex_event.js");
 const metadata_js_1 = require("../core/metadata.js");
@@ -58,7 +28,11 @@ function cancelSubscribeStream(stream) {
     // Stream destruction can emit an error during the short setup window before
     // the normal lifecycle listeners have been installed.
     stream.once("error", () => { });
-    stream.destroy();
+    const cancellable = stream;
+    if (typeof cancellable.cancel === "function")
+        cancellable.cancel();
+    else
+        stream.destroy();
 }
 function positiveIntegerOption(value, fallback, name) {
     const normalized = value ?? fallback;
@@ -74,7 +48,7 @@ function replayUnsupported(error) {
     return /from.?slot.*(?:unsupported|disabled|unavailable|invalid)/i.test(`${grpcError.message ?? ""} ${grpcError.details ?? ""}`);
 }
 function updateSlot(update) {
-    const value = update.transaction?.slot ?? update.account?.slot;
+    const value = update.transaction?.slot ?? update.account?.slot ?? update.blockMeta?.slot;
     if (value === undefined || value === null)
         return undefined;
     try {
@@ -91,6 +65,8 @@ function updateIdentity(update) {
     const transaction = update.transaction?.transaction;
     if (transaction?.signature)
         return `t:${bytesKey(transaction.signature)}`;
+    if (update.blockMeta)
+        return `b:${String(update.blockMeta.slot)}:${update.blockMeta.blockhash}`;
     const account = update.account?.account;
     if (!account?.pubkey)
         return undefined;
@@ -104,10 +80,28 @@ class YellowstoneGrpc {
     connectPromise;
     subscribers = new Map();
     dexSubscribers = new Map();
+    dexLifecycle = Promise.resolve();
+    activeDex;
+    withDexLifecycle(work) {
+        const result = this.dexLifecycle.then(work);
+        this.dexLifecycle = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async stopDexUnlocked() {
+        const active = this.activeDex;
+        this.activeDex = undefined;
+        if (active) {
+            active.cancel();
+            await active.join();
+        }
+    }
+    async stop() {
+        await this.withDexLifecycle(() => this.stopDexUnlocked());
+    }
     constructor(endpoint, xToken, config = (0, types_js_1.defaultClientConfig)()) {
         this.config = config;
         const gc = (0, geyser_connect_js_1.defaultGeyserConnectConfig)();
-        this.client = new yellowstone_grpc_1.default(endpoint, xToken || undefined, (0, geyser_connect_js_1.geyserGrpcChannelOptions)({
+        this.client = new native_client_js_1.default(endpoint, xToken || undefined, (0, geyser_connect_js_1.geyserGrpcChannelOptions)({
             ...gc,
             keepAliveIntervalMs: config.keep_alive_interval_ms,
             keepAliveTimeoutMs: config.keep_alive_timeout_ms,
@@ -135,6 +129,7 @@ class YellowstoneGrpc {
     }
     /** 断开连接 */
     async disconnect() {
+        await this.stop();
         for (const [, sub] of this.subscribers) {
             sub.cancel();
         }
@@ -143,6 +138,7 @@ class YellowstoneGrpc {
             sub.cancel();
         }
         this.dexSubscribers.clear();
+        this.client.close?.();
         this.connected = false;
         this.connectPromise = undefined;
     }
@@ -265,7 +261,7 @@ class YellowstoneGrpc {
             entry: {},
             blocks: {},
             blocksMeta: {},
-            commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
+            commitment: geyser_js_1.CommitmentLevel.CONFIRMED,
             accountsDataSlice: [],
             ping: { id: 1 },
         };
@@ -276,7 +272,7 @@ class YellowstoneGrpc {
         return value instanceof Uint8Array ? value : Uint8Array.from(value);
     }
     static toBigInt(value) {
-        return typeof value === "bigint" ? value : BigInt(value);
+        return (0, metadata_js_1.exactU64)(value);
     }
     static protobufNumber(value) {
         if (typeof value === "bigint")
@@ -297,18 +293,20 @@ class YellowstoneGrpc {
     static timestampToMicros(value) {
         if (value instanceof Date) {
             const milliseconds = value.getTime();
-            return Number.isFinite(milliseconds) ? Math.trunc(milliseconds * 1_000) : undefined;
+            return Number.isFinite(milliseconds) ? BigInt(milliseconds) * 1000n : undefined;
         }
         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);
+        const seconds = (0, metadata_js_1.exactInteger)(typeof ts.seconds === "object" && ts.seconds !== null ? ts.seconds.toString() : ts.seconds, "timestamp seconds");
+        const nanos = (0, metadata_js_1.exactInteger)((ts.nanos ?? 0), "timestamp nanos");
+        if (nanos < 0n || nanos >= 1000000000n)
+            throw new RangeError("Invalid timestamp nanos");
+        const micros = seconds * 1000000n + nanos / 1000n;
+        const lo = -(1n << 63n), hi = (1n << 63n) - 1n;
+        return micros < lo ? lo : micros > hi ? hi : micros;
     }
     parseAccountEvent(update, grpcRecvUs, eventTypeFilter, blockTimeUs) {
         const acc = update.account;
@@ -323,10 +321,10 @@ class YellowstoneGrpc {
             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);
+        const metadata = (0, metadata_js_1.makeMetadata)(signatureBytes.length > 0 ? bs58_1.default.encode(signatureBytes) : "", update.slot, 0, blockTimeUs, grpcRecvUs);
         return (0, mod_js_1.parseAccountUnified)(account, metadata, eventTypeFilter);
     }
-    parseAccountEventRaw(update, grpcRecvUs, eventTypeFilter, blockTimeUs) {
+    parseAccountEventRaw(update, grpcRecvUs, eventTypeFilter, blockTimeUs, rawSnapshot = false) {
         const acc = update.account;
         if (!acc)
             return null;
@@ -339,7 +337,9 @@ class YellowstoneGrpc {
             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) : "", YellowstoneGrpc.protobufNumber(update.slot), 0, blockTimeUs, grpcRecvUs);
+        const metadata = (0, metadata_js_1.makeMetadata)(signatureBytes.length > 0 ? bs58_1.default.encode(signatureBytes) : "", update.slot, 0, blockTimeUs, grpcRecvUs);
+        if (rawSnapshot)
+            return { RawAccountSnapshot: { metadata, account: { ...account, data: Uint8Array.from(account.data) }, write_version: YellowstoneGrpc.toBigInt(acc.writeVersion), is_startup: update.isStartup } };
         return (0, mod_js_1.parseAccountUnified)(account, metadata, eventTypeFilter);
     }
     initialSubscribeRequest(filter) {
@@ -360,7 +360,7 @@ class YellowstoneGrpc {
             entry: {},
             blocks: {},
             blocksMeta: {},
-            commitment: yellowstone_grpc_1.CommitmentLevel.CONFIRMED,
+            commitment: geyser_js_1.CommitmentLevel.CONFIRMED,
             accountsDataSlice: [],
             ping: undefined,
         };
@@ -377,7 +377,7 @@ class YellowstoneGrpc {
             streamHolder.current = null;
         };
         this.subscribers.set(id, { filter, callbacks, cancel });
-        (async () => {
+        const streamTask = (async () => {
             const autoReconnect = callbacks.autoReconnect !== false;
             const maxBackoffMs = 60_000;
             let backoffMs = this.config.retry_delay_ms;
@@ -482,6 +482,12 @@ class YellowstoneGrpc {
      * 事件队列满时按配置丢弃事件，避免回调阻塞 gRPC 读循环并让丢弃可观测。
      */
     async subscribeDexEvents(transactionFilters = [], accountFilters = [], eventTypeFilter, options) {
+        return this.withDexLifecycle(async () => {
+            await this.stopDexUnlocked();
+            return this.startDexEvents(transactionFilters, accountFilters, eventTypeFilter, options);
+        });
+    }
+    async startDexEvents(transactionFilters = [], accountFilters = [], eventTypeFilter, options) {
         await this.connect();
         const id = `dex_${Date.now()}_${Math.random().toString(36).slice(2)}`;
         const events = new async_event_queue_js_1.AsyncEventQueue(Math.max(1, this.config.buffer_size), options?.queueOverflowStrategy);
@@ -504,11 +510,23 @@ class YellowstoneGrpc {
         let highestRememberedSlot = 0n;
         let seenHead = 0;
         const seenUpdates = new Map();
+        const accountFingerprints = new Map();
         const seenOrder = [];
+        const states = new async_event_queue_js_1.AsyncEventQueue(Math.max(1, this.config.buffer_size));
+        let streamStatus = Object.freeze({ state: "connecting", continuityBroken: false, reconnects: 0, dropped: 0 });
+        states.push(streamStatus);
+        const transition = (state, broken = false) => {
+            const next = Object.freeze({ state, continuityBroken: streamStatus.continuityBroken || broken, reconnects: reconnectCount, dropped: eventDropped() + ingress.dropped() });
+            if (next.state === streamStatus.state && next.continuityBroken === streamStatus.continuityBroken && next.reconnects === streamStatus.reconnects && next.dropped === streamStatus.dropped)
+                return;
+            streamStatus = next;
+            states.push(next);
+        };
         const reportError = (error) => errors.push(error);
         const emitEvent = (event) => {
             if (events.push(event))
                 return;
+            transition(streamStatus.state, true);
             const now = Date.now();
             if (now < nextEventDropWarningAt)
                 return;
@@ -552,12 +570,14 @@ class YellowstoneGrpc {
                 }
             }
         };
-        const rememberParsedUpdate = (identity, slot) => {
+        const rememberParsedUpdate = (identity, slot, fingerprint) => {
             if (slot !== undefined && (lastParsedSlot === undefined || slot > lastParsedSlot)) {
                 lastParsedSlot = slot;
             }
-            if (!replayOnReconnect || identity === undefined || slot === undefined)
+            if (identity === undefined || slot === undefined)
                 return;
+            if (fingerprint !== undefined)
+                accountFingerprints.set(identity, fingerprint);
             seenUpdates.set(identity, slot);
             seenOrder.push({ identity, slot });
             if (slot > highestRememberedSlot)
@@ -567,8 +587,10 @@ class YellowstoneGrpc {
                 : 0n;
             while (seenHead < seenOrder.length && seenOrder[seenHead].slot < retainFrom) {
                 const stale = seenOrder[seenHead++];
-                if (seenUpdates.get(stale.identity) === stale.slot)
+                if (seenUpdates.get(stale.identity) === stale.slot) {
                     seenUpdates.delete(stale.identity);
+                    accountFingerprints.delete(stale.identity);
+                }
             }
             if (seenHead >= 4096 && seenHead * 2 >= seenOrder.length) {
                 seenOrder.splice(0, seenHead);
@@ -578,6 +600,12 @@ class YellowstoneGrpc {
         const processUpdate = ({ update, grpcRecvUs, grpcRecvNs, blockTimeUs, sourceToGrpcLatencyUs, }) => {
             const identity = updateIdentity(update);
             const slotForReplay = updateSlot(update);
+            const raw = update.account?.account;
+            const fingerprint = raw ? (0, node_crypto_1.createHash)("sha256").update(raw.owner).update(raw.data).update(`${raw.lamports}:${raw.executable}:${raw.rentEpoch}`).digest("hex") : undefined;
+            if (identity && fingerprint && accountFingerprints.has(identity) && accountFingerprints.get(identity) !== fingerprint) {
+                transition(streamStatus.state, true);
+                throw Error("Conflicting account version; select and revalidate a fork explicitly");
+            }
             if (replayOnReconnect && identity !== undefined && seenUpdates.has(identity)) {
                 replayedUpdateCount++;
                 rememberParsedUpdate(undefined, slotForReplay);
@@ -590,8 +618,8 @@ class YellowstoneGrpc {
             if (tx) {
                 const parseStartedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
                 const slot = txUpdate?.slot ?? 0n;
-                const fallbackSlot = YellowstoneGrpc.protobufNumber(slot);
-                const fallbackTxIndex = YellowstoneGrpc.protobufNumber(tx.index ?? 0);
+                const fallbackSlot = YellowstoneGrpc.toBigInt(slot);
+                const fallbackTxIndex = YellowstoneGrpc.toBigInt(tx.index ?? 0);
                 const txInfo = {
                     signature: tx.signature,
                     isVote: tx.isVote,
@@ -608,9 +636,23 @@ class YellowstoneGrpc {
                 annotateLocalMetrics(txEvents, grpcRecvNs, parseStartedNs, parseFinishedNs, sourceToGrpcLatencyUs);
                 order.pushTransactionEvents(txEvents, fallbackSlot, fallbackTxIndex, emitEvent);
             }
+            if (update.blockMeta) {
+                const event = (0, block_meta_js_1.parseBlockMetaUpdate)(update.blockMeta, grpcRecvUs, blockTimeUs);
+                if (!eventTypeFilter || eventTypeFilter.shouldInclude("BlockMeta"))
+                    emitEvent(event);
+            }
             if (update.account) {
+                const rawOnly = !!eventTypeFilter?.include_only?.length &&
+                    eventTypeFilter.include_only.every(type => type === "AccountRawSnapshot");
+                if (eventTypeFilter?.include_only?.includes('AccountRawSnapshot')) {
+                    const snapshot = this.parseAccountEventRaw(update.account, grpcRecvUs, eventTypeFilter, blockTimeUs, true);
+                    if (snapshot)
+                        emitEvent(snapshot);
+                }
                 const parseStartedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
-                const ev = this.parseAccountEventRaw(update.account, grpcRecvUs, eventTypeFilter, blockTimeUs);
+                // Raw-only cache subscriptions do not need a second normalization,
+                // base58 conversion and protocol decode for the same account bytes.
+                const ev = rawOnly ? null : this.parseAccountEventRaw(update.account, grpcRecvUs, eventTypeFilter, blockTimeUs);
                 const parseFinishedNs = grpcRecvNs === undefined ? undefined : process.hrtime.bigint();
                 if (ev) {
                     annotateLocalMetrics([ev], grpcRecvNs, parseStartedNs, parseFinishedNs, sourceToGrpcLatencyUs);
@@ -618,7 +660,7 @@ class YellowstoneGrpc {
                 if (ev)
                     emitEvent(ev);
             }
-            rememberParsedUpdate(identity, slotForReplay);
+            rememberParsedUpdate(identity, slotForReplay, fingerprint);
         };
         const scheduleIngressDrain = () => {
             if (isCancelled || ingressDrainScheduled || ingress.len() === 0)
@@ -640,6 +682,7 @@ class YellowstoneGrpc {
                         processUpdate(pending);
                     }
                     catch (err) {
+                        transition(streamStatus.state, true);
                         reportError(err instanceof Error ? err : new Error(String(err)));
                     }
                     processed++;
@@ -677,6 +720,8 @@ class YellowstoneGrpc {
         });
         const cancel = () => {
             isCancelled = true;
+            transition("stopped", true);
+            states.close();
             cancelReconnectDelay?.();
             cancelSubscribeStream(streamHolder.current);
             streamHolder.current = null;
@@ -699,7 +744,7 @@ class YellowstoneGrpc {
             if (!stream)
                 return;
             await new Promise((resolve, reject) => {
-                stream.write((0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters), (err) => {
+                stream.write((0, subscribe_builder_js_1.buildSubscribeRequestWithEventFilter)(currentTransactionFilters, currentAccountFilters, eventTypeFilter), (err) => {
                     if (err)
                         reject(err);
                     else
@@ -708,7 +753,7 @@ class YellowstoneGrpc {
             });
         };
         this.dexSubscribers.set(id, { cancel, update });
-        (async () => {
+        const streamTask = (async () => {
             const autoReconnect = options?.autoReconnect !== false;
             const maxBackoffMs = 60_000;
             let backoffMs = this.config.retry_delay_ms;
@@ -722,13 +767,14 @@ class YellowstoneGrpc {
                         attempt++;
                         if (attempt > 1)
                             reconnectCount++;
+                        transition(attempt > 1 ? "reconnecting" : "connecting");
                         const stream = await this.client.subscribe();
                         if (isCancelled) {
                             cancelSubscribeStream(stream);
                             break;
                         }
                         streamHolder.current = stream;
-                        const request = (0, subscribe_builder_js_1.buildSubscribeRequest)(currentTransactionFilters, currentAccountFilters);
+                        const request = (0, subscribe_builder_js_1.buildSubscribeRequestWithEventFilter)(currentTransactionFilters, currentAccountFilters, eventTypeFilter);
                         if (attempt > 1 && replayAllowed && lastParsedSlot !== undefined) {
                             request.fromSlot = lastParsedSlot.toString();
                             attemptedReplay = true;
@@ -742,6 +788,7 @@ class YellowstoneGrpc {
                             });
                         });
                         streamConnected = true;
+                        transition("connected");
                         await new Promise((resolve, reject) => {
                             const cleanup = () => {
                                 streamConnected = false;
@@ -773,9 +820,10 @@ class YellowstoneGrpc {
                                     grpcRecvUs,
                                     grpcRecvNs,
                                     blockTimeUs: createdAtUs,
-                                    sourceToGrpcLatencyUs: createdAtUs === undefined ? undefined : Math.max(0, grpcRecvUs - createdAtUs),
+                                    sourceToGrpcLatencyUs: createdAtUs === undefined ? undefined : Math.max(0, Number((0, metadata_js_1.exactI64)(grpcRecvUs) - createdAtUs)),
                                 });
                                 if (!accepted) {
+                                    transition(streamStatus.state, true);
                                     const now = Date.now();
                                     if (now >= nextIngressDropWarningAt) {
                                         nextIngressDropWarningAt = now + 10_000;
@@ -788,11 +836,15 @@ class YellowstoneGrpc {
                             });
                             stream.on("error", (err) => {
                                 streamDisconnectCount++;
+                                if (!isCancelled)
+                                    transition("reconnecting", true);
                                 cleanup();
                                 reject(err);
                             });
                             stream.on("end", () => {
                                 streamDisconnectCount++;
+                                if (!isCancelled)
+                                    transition("reconnecting", true);
                                 cleanup();
                                 if (!isCancelled)
                                     reportError(new Error("Yellowstone stream ended; reconnecting"));
@@ -806,6 +858,7 @@ class YellowstoneGrpc {
                         cancelSubscribeStream(streamHolder.current);
                         streamHolder.current = null;
                         streamConnected = false;
+                        transition("reconnecting", true);
                         reportError(err instanceof Error ? err : new Error(String(err)));
                         await waitForIngressIdle();
                         if (!autoReconnect) {
@@ -854,12 +907,18 @@ class YellowstoneGrpc {
                 ingress.close();
                 events.close();
                 errors.close();
+                transition("stopped", true);
+                states.close();
                 this.dexSubscribers.delete(id);
             }
         })();
+        this.activeDex = { cancel, join: () => streamTask };
         return Object.assign(events, {
             id,
+            join: () => streamTask,
             errors,
+            states,
+            status: () => streamStatus,
             dropped: () => eventDropped() + ingress.dropped(),
             eventDropped,
             ingressLen: () => ingress.len(),
@@ -890,6 +949,9 @@ class YellowstoneGrpc {
     }
     /** 动态更新当前 DEX 订阅过滤器（与 Rust update_subscription 语义对齐）。 */
     async updateSubscription(transactionFilters, accountFilters) {
+        return this.withDexLifecycle(() => this.updateDexUnlocked(transactionFilters, accountFilters));
+    }
+    async updateDexUnlocked(transactionFilters, accountFilters) {
         const active = this.dexSubscribers.values().next().value;
         if (!active?.update) {
             throw new Error("No active DEX subscription");
@@ -904,22 +966,22 @@ class YellowstoneGrpc {
         await this.connect();
         const resp = await this.client.getLatestBlockhash(commitment);
         return {
-            slot: Number(resp.slot),
+            slot: (0, metadata_js_1.exactU64)(resp.slot),
             blockhash: resp.blockhash,
-            lastValidBlockHeight: Number(resp.lastValidBlockHeight),
+            lastValidBlockHeight: (0, metadata_js_1.exactU64)(resp.lastValidBlockHeight),
         };
     }
     /** 获取区块高度 */
     async getBlockHeight(commitment) {
         await this.connect();
         const resp = await this.client.getBlockHeight(commitment);
-        return Number(resp.blockHeight);
+        return (0, metadata_js_1.exactU64)(resp.blockHeight);
     }
     /** 获取当前 Slot */
     async getSlot(commitment) {
         await this.connect();
         const resp = await this.client.getSlot(commitment);
-        return Number(resp.slot);
+        return (0, metadata_js_1.exactU64)(resp.slot);
     }
     /** 获取服务器版本 */
     async getVersion() {
@@ -932,7 +994,7 @@ class YellowstoneGrpc {
         await this.connect();
         const resp = await this.client.isBlockhashValid(blockhash, commitment);
         return {
-            slot: Number(resp.slot),
+            slot: (0, metadata_js_1.exactU64)(resp.slot),
             valid: resp.valid,
         };
     }

package/dist/grpc/geyser_connect.d.ts

@@ -1,10 +1,10 @@
 /**
  * 与 Rust `sol-parser-sdk/src/grpc/geyser_connect.rs` 对齐：Yellowstone Geyser gRPC 连接选项。
  *
- * `@triton-one/yellowstone-grpc` 的 `Client` 通过构造函数第三参传入 `ChannelOptions`；
- * `connectTimeoutMs` 无与 tonic 完全一一对应的项，仅作文档与默认值对齐（可配合环境网络调优）。
+ * 纯 JavaScript `@grpc/grpc-js` 传输，不加载 Rust N-API；
+ * `connectTimeoutMs` 用于 waitForReady 与 unary deadline。
  */
-import Client, { type ChannelOptions } from "@triton-one/yellowstone-grpc";
+import Client, { type NativeChannelOptions as ChannelOptions } from "./native_client.js";
 /** 与 Rust `GeyserConnectConfig` 字段对应（毫秒 / 字节） */
 export interface GeyserConnectConfig {
     /** 对应 Rust `connect_timeout`（毫秒） */

package/dist/grpc/geyser_connect.js

@@ -9,10 +9,10 @@ exports.connectYellowstoneGeyser = connectYellowstoneGeyser;
 /**
  * 与 Rust `sol-parser-sdk/src/grpc/geyser_connect.rs` 对齐：Yellowstone Geyser gRPC 连接选项。
  *
- * `@triton-one/yellowstone-grpc` 的 `Client` 通过构造函数第三参传入 `ChannelOptions`；
- * `connectTimeoutMs` 无与 tonic 完全一一对应的项，仅作文档与默认值对齐（可配合环境网络调优）。
+ * 纯 JavaScript `@grpc/grpc-js` 传输，不加载 Rust N-API；
+ * `connectTimeoutMs` 用于 waitForReady 与 unary deadline。
  */
-const yellowstone_grpc_1 = __importDefault(require("@triton-one/yellowstone-grpc"));
+const native_client_js_1 = __importDefault(require("./native_client.js"));
 /** 公共字段与 Rust `GeyserConnectConfig::default` 一致，并包含 Node gRPC 通道默认值。 */
 function defaultGeyserConnectConfig() {
     return {
@@ -32,17 +32,15 @@ function geyserGrpcChannelOptions(config = defaultGeyserConnectConfig()) {
     const interval = config.keepAliveIntervalMs ?? 30_000;
     const timeout = config.keepAliveTimeoutMs ?? 5000;
     return {
-        grpcConnectTimeout: config.connectTimeoutMs,
-        grpcMaxDecodingMessageSize: max,
-        grpcMaxEncodingMessageSize: max,
-        grpcHttp2KeepAliveInterval: interval,
-        grpcKeepAliveTimeout: timeout,
-        grpcTcpKeepalive: interval,
-        grpcInitialConnectionWindowSize: config.flowControlWindowBytes,
-        grpcInitialStreamWindowSize: config.flowControlWindowBytes,
-        grpcHttp2AdaptiveWindow: true,
-        grpcKeepAliveWhileIdle: true,
-        grpcTcpNodelay: true,
+        connectTimeoutMs: config.connectTimeoutMs,
+        "grpc.max_receive_message_length": max,
+        "grpc.max_send_message_length": max,
+        "grpc.keepalive_time_ms": interval,
+        "grpc.keepalive_timeout_ms": timeout,
+        "grpc.keepalive_permit_without_calls": 1,
+        "grpc.initial_reconnect_backoff_ms": config.initialReconnectBackoffMs ?? 1000,
+        "grpc.max_reconnect_backoff_ms": config.maxReconnectBackoffMs ?? 60000,
+        "grpc-node.flow_control_window": config.flowControlWindowBytes ?? 1024 * 1024,
     };
 }
 /**
@@ -50,7 +48,7 @@ function geyserGrpcChannelOptions(config = defaultGeyserConnectConfig()) {
  * Rust 为 async；此处构造同步完成，返回 `Promise` 以保持 `await connectYellowstoneGeyser(...)` 写法。
  */
 async function connectYellowstoneGeyser(endpoint, config = defaultGeyserConnectConfig()) {
-    const client = new yellowstone_grpc_1.default(endpoint, config.xToken, geyserGrpcChannelOptions(config));
+    const client = new native_client_js_1.default(endpoint, config.xToken, geyserGrpcChannelOptions(config));
     await client.connect();
     return client;
 }

package/dist/grpc/log_instr_dedup.js

@@ -168,6 +168,8 @@ function mergePumpfunTrade(log, ix) {
         "quote_amount",
         "virtual_quote_reserves",
         "real_quote_reserves",
+        "holder_rewards_bps",
+        "holder_rewards",
     ]) {
         fillNonZero(log, key, ix);
     }
@@ -197,6 +199,7 @@ function mergePumpfunCreate(log, ix) {
         "real_token_reserves",
         "token_total_supply",
         "virtual_quote_reserves",
+        "creator_fee_bps",
     ]) {
         fillNonZero(log, key, ix);
     }
@@ -204,6 +207,7 @@ function mergePumpfunCreate(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);
+    log.is_holder_reward = Boolean(log.is_holder_reward) || Boolean(ix.is_holder_reward);
 }
 function mergePumpfunCreateV2(log, ix) {
     mergePumpfunCreate(log, ix);
@@ -224,6 +228,8 @@ function mergePumpfunCreateV2(log, ix) {
     ]) {
         fillString(log, key, ix);
     }
+    fillNonZero(log, "creator_fee_bps", ix);
+    log.is_holder_reward = Boolean(log.is_holder_reward) || Boolean(ix.is_holder_reward);
 }
 function mergePumpfunMigrate(log, ix) {
     for (const key of ["bonding_curve", "pool", "user"]) {

package/dist/grpc/native_client.d.ts

@@ -0,0 +1,26 @@
+/** Pure JavaScript Yellowstone transport. Exact protobuf integers are decimal strings. */
+import * as grpc from "@grpc/grpc-js";
+import type { CommitmentLevel, SubscribeRequest, SubscribeUpdate } from "./protocol/geyser.js";
+export interface NativeChannelOptions extends grpc.ChannelOptions {
+    connectTimeoutMs?: number;
+}
+export declare const geyserService: grpc.ServiceDefinition<grpc.UntypedServiceImplementation>;
+export default class NativeYellowstoneClient {
+    private readonly options;
+    private raw?;
+    private readonly address;
+    private readonly credentials;
+    private readonly metadata;
+    constructor(endpoint: string, token?: string, options?: NativeChannelOptions);
+    private client;
+    connect(): Promise<void>;
+    close(): void;
+    subscribe(): Promise<grpc.ClientDuplexStream<SubscribeRequest, SubscribeUpdate>>;
+    private unary;
+    getLatestBlockhash(commitment?: CommitmentLevel): Promise<any>;
+    getBlockHeight(commitment?: CommitmentLevel): Promise<any>;
+    getSlot(commitment?: CommitmentLevel): Promise<any>;
+    getVersion(): Promise<any>;
+    isBlockhashValid(blockhash: string, commitment?: CommitmentLevel): Promise<any>;
+    ping(count: number): Promise<number>;
+}