@triton-one/yellowstone-grpc 5.0.2 → 5.0.4

package/dist/esm/index.js

@@ -1,10 +1,31 @@
 /** TypeScript/JavaScript client for gRPC Geyser. */
 // Import generated gRPC client and types.
-import { SubscribeUpdateTransactionInfo } from "./grpc/geyser.js";
+import { GetBlockHeightResponse as GetBlockHeightResponseMessage, GetLatestBlockhashResponse as GetLatestBlockhashResponseMessage, GetSlotResponse as GetSlotResponseMessage, GetVersionResponse as GetVersionResponseMessage, IsBlockhashValidResponse as IsBlockhashValidResponseMessage, PongResponse as PongResponseMessage, SubscribeReplayInfoResponse as SubscribeReplayInfoResponseMessage, SubscribeUpdateTransactionInfo, } from "./grpc/geyser.js";
 // Reexport automatically generated types
 export { CommitmentLevel, SubscribeRequest, SubscribeRequest_AccountsEntry, SubscribeRequest_BlocksEntry, SubscribeRequest_BlocksMetaEntry, SubscribeRequest_SlotsEntry, SubscribeRequest_TransactionsEntry, SubscribeRequestAccountsDataSlice, SubscribeRequestFilterAccounts, SubscribeRequestFilterAccountsFilter, SubscribeRequestFilterAccountsFilterLamports, SubscribeRequestFilterAccountsFilterMemcmp, SubscribeRequestFilterBlocks, SubscribeRequestFilterBlocksMeta, SubscribeRequestFilterEntry, SubscribeRequestFilterSlots, SubscribeRequestFilterTransactions, SubscribeUpdate, SubscribeUpdateAccount, SubscribeUpdateAccountInfo, SubscribeUpdateBlock, SubscribeUpdateBlockMeta, SubscribeUpdatePing, SubscribeUpdateSlot, SubscribeUpdateTransaction, SubscribeUpdateTransactionInfo, } from "./grpc/geyser.js";
 import { Duplex } from "stream";
 import * as napi from "./napi/index.js";
+/**
+ * Convert N-API `JsSubscribeUpdate` shape (with `updateOneof`) into the
+ * generated protobuf-friendly SDK shape (`SubscribeUpdate`) where the oneof
+ * variants are top-level optional fields.
+ */
+function fromJsSubscribeUpdate(update) {
+    const oneof = update.updateOneof ?? {};
+    return {
+        filters: update.filters ?? [],
+        createdAt: update.createdAt,
+        account: oneof.account,
+        slot: oneof.slot,
+        transaction: oneof.transaction,
+        transactionStatus: oneof.transactionStatus,
+        block: oneof.block,
+        ping: oneof.ping,
+        pong: oneof.pong,
+        blockMeta: oneof.blockMeta,
+        entry: oneof.entry,
+    };
+}
 export default class Client {
     _insecureEndpoint;
     _insecureXToken;
@@ -15,71 +36,88 @@ export default class Client {
         this._insecureXToken = xToken;
         this._channelOptions = channel_options;
     }
+    _connectedGrpcClient() {
+        if (!this._grpcClient) {
+            throw new Error("Client not connected. Call connect() first");
+        }
+        return this._grpcClient;
+    }
     async connect() {
-        // Use the factory method to create the client
+        // Establish one persistent native gRPC client reused by all calls.
         this._grpcClient = await napi.GrpcClient.new(this._insecureEndpoint, this._insecureXToken, this._channelOptions);
     }
     async getLatestBlockhash(commitment) {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {
             commitment: commitment ?? null,
         };
-        return await this._grpcClient.getLatestBlockhash(request);
+        const response = await grpcClient.getLatestBlockhash(request);
+        return GetLatestBlockhashResponseMessage.fromPartial({
+            slot: response.slot,
+            blockhash: response.blockhash,
+            lastValidBlockHeight: response.lastValidBlockHeight,
+        });
     }
     async ping(count) {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {
             count,
         };
-        return (await this._grpcClient.ping(request)).count;
+        const response = await grpcClient.ping(request);
+        return PongResponseMessage.fromPartial({
+            count: response.count,
+        });
     }
     async getBlockHeight(commitment) {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {
             commitment,
         };
-        return (await this._grpcClient.getBlockHeight(request)).blockHeight;
+        const response = await grpcClient.getBlockHeight(request);
+        return GetBlockHeightResponseMessage.fromPartial({
+            blockHeight: response.blockHeight,
+        });
     }
     async getSlot(commitment) {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {
             commitment,
         };
-        return (await this._grpcClient.getSlot(request)).slot;
+        const response = await grpcClient.getSlot(request);
+        return GetSlotResponseMessage.fromPartial({
+            slot: response.slot,
+        });
     }
     async isBlockhashValid(blockhash, commitment) {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {
             blockhash,
             commitment,
         };
-        return await this._grpcClient.isBlockhashValid(request);
+        const response = await grpcClient.isBlockhashValid(request);
+        return IsBlockhashValidResponseMessage.fromPartial({
+            slot: response.slot,
+            valid: response.valid,
+        });
     }
     async getVersion() {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {};
-        return (await this._grpcClient.getVersion(request)).version;
+        const response = await grpcClient.getVersion(request);
+        return GetVersionResponseMessage.fromPartial({
+            version: response.version,
+        });
     }
     async subscribeReplayInfo() {
-        if (!this._grpcClient) {
-            throw new Error("Client not connected. Call connect() first");
-        }
+        const grpcClient = this._connectedGrpcClient();
         const request = {};
-        return await this._grpcClient.subscribeReplayInfo(request);
+        const response = await grpcClient.subscribeReplayInfo(request);
+        return SubscribeReplayInfoResponseMessage.fromPartial({
+            firstAvailable: response.firstAvailable,
+        });
     }
     async subscribe() {
+        const grpcClient = this._connectedGrpcClient();
         // Inner stream.Duplex config passed to both stream.Readable and Writable.
         // See: https://nodejs.org/en/blog/feature/streams2#new-streamduplexoptions
         const options = {
@@ -90,7 +128,9 @@ export default class Client {
             // TODO: Fine tune high watermark for performance and backpressure.
             // highWaterMark: 16
         };
-        const stream = this._grpcClient.subscribe();
+        // Native stream produces N-API generated JS objects; wrapper below adapts
+        // to public protobuf-generated SDK shapes and Node stream semantics.
+        const stream = grpcClient.subscribe();
         return new Promise((resolve, reject) => {
             try {
                 resolve(new ClientDuplexStream(stream, options));
@@ -101,23 +141,102 @@ export default class Client {
         });
     }
 }
-class ClientDuplexStream extends Duplex {
+export class ClientDuplexStream extends Duplex {
     _napiDuplexStream;
+    // Prevent overlapping native reads: a single pending read at a time.
+    _readInFlight;
+    // Closed once Node emits `close`.
+    _isClosed;
+    // Set during destroy path to short-circuit late async completions.
+    _isDestroying;
+    // Ensure we surface at most one terminal error per stream instance.
+    _terminalErrorSeen;
     constructor(stream, options) {
         super({ ...options });
         this._napiDuplexStream = stream;
+        this._readInFlight = false;
+        this._isClosed = false;
+        this._isDestroying = false;
+        this._terminalErrorSeen = false;
+        this.once("close", () => {
+            this._isClosed = true;
+        });
     }
-    async _read(_size) {
-        try {
-            const update = await this._napiDuplexStream.read();
-            this.push(update);
+    _pullNextUpdate() {
+        if (this._isClosed || this._isDestroying || this._readInFlight) {
+            return;
         }
-        catch (err) {
+        this._readInFlight = true;
+        this._napiDuplexStream
+            .read()
+            .then((update) => {
+            this._readInFlight = false;
+            if (this._isClosed || this._isDestroying) {
+                return;
+            }
+            // Native side can signal EOF by returning no update.
+            if (update == null) {
+                this.push(null);
+                this.destroy();
+                return;
+            }
+            const grpcUpdate = fromJsSubscribeUpdate(update);
+            // Respect backpressure: only pull again if consumer accepted push.
+            const canContinue = this.push(grpcUpdate);
+            if (canContinue) {
+                this._pullNextUpdate();
+            }
+        })
+            .catch((err) => {
+            this._readInFlight = false;
+            if (this._isClosed || this._isDestroying) {
+                return;
+            }
+            if (this._terminalErrorSeen) {
+                return;
+            }
+            this._terminalErrorSeen = true;
+            // Detect normal end-of-stream / "no update available" sentinel from native side.
+            const e = err;
+            const isNormalEof = err == null ||
+                (e && typeof e.code === "string" && e.code === "NO_UPDATE_AVAILABLE") ||
+                (e &&
+                    typeof e.message === "string" &&
+                    e.message.toLowerCase().includes("no update available"));
             this.push(null); // Signal end of stream
-            this.destroy(err); // Handle resource cleanup
+            if (isNormalEof) {
+                // Graceful shutdown: end without emitting an error event.
+                this.destroy();
+            }
+            else {
+                // Real error: propagate as a stream error.
+                this.destroy(err);
+            }
+        });
+    }
+    _read(_size) {
+        this._pullNextUpdate();
+    }
+    _destroy(error, callback) {
+        // Mark terminal state first so late read completions are ignored.
+        this._isDestroying = true;
+        this._isClosed = true;
+        this._terminalErrorSeen = true;
+        // Explicitly stop the native worker so it does not outlive JS stream state.
+        try {
+            const nativeStream = this._napiDuplexStream;
+            if (typeof nativeStream.close === "function") {
+                nativeStream.close();
+            }
         }
+        catch { }
+        callback(error);
     }
     _write(chunk, _encoding, callback) {
+        if (this._isClosed || this._isDestroying) {
+            callback(new Error("Cannot write to a closed subscription stream"));
+            return;
+        }
         try {
             this._napiDuplexStream.write(chunk);
             callback();

package/dist/types/grpc/geyser.d.ts

@@ -122,6 +122,19 @@ export interface SubscribeRequestFilterBlocksMeta {
 }
 export interface SubscribeRequestFilterEntry {
 }
+/**
+ * Filter for deshred transactions (transactions received before execution).
+ * Deshred transactions are received when entries are formed from shreds,
+ * BEFORE any execution occurs. No TransactionStatusMeta is available.
+ * Address lookup tables are resolved, so both static account keys and
+ * dynamically loaded addresses (from ALTs) are available for filtering.
+ */
+export interface SubscribeRequestFilterDeshredTransactions {
+    vote?: boolean | undefined;
+    accountInclude: string[];
+    accountExclude: string[];
+    accountRequired: string[];
+}
 export interface SubscribeRequestAccountsDataSlice {
     offset: string;
     length: string;
@@ -129,6 +142,24 @@ export interface SubscribeRequestAccountsDataSlice {
 export interface SubscribeRequestPing {
     id: number;
 }
+/**
+ * Request message for the SubscribeDeshred RPC.
+ * Subscribes to deshred transactions (transactions received before execution).
+ * Deshred transactions are received when entries are formed from shreds,
+ * BEFORE any execution occurs. No TransactionStatusMeta is available.
+ * Address lookup tables are resolved, so both static and loaded addresses
+ * are available for filtering.
+ */
+export interface SubscribeDeshredRequest {
+    deshredTransactions: {
+        [key: string]: SubscribeRequestFilterDeshredTransactions;
+    };
+    ping?: SubscribeRequestPing | undefined;
+}
+export interface SubscribeDeshredRequest_DeshredTransactionsEntry {
+    key: string;
+    value: SubscribeRequestFilterDeshredTransactions | undefined;
+}
 export interface SubscribeUpdate {
     filters: string[];
     account?: SubscribeUpdateAccount | undefined;
@@ -216,11 +247,29 @@ export interface SubscribeUpdateEntry {
     /** added in v1.18, for solana 1.17 value is always 0 */
     startingTransactionIndex: string;
 }
+export interface SubscribeUpdateDeshredTransaction {
+    transaction: SubscribeUpdateDeshredTransactionInfo | undefined;
+    slot: string;
+}
+export interface SubscribeUpdateDeshredTransactionInfo {
+    signature: Uint8Array;
+    isVote: boolean;
+    transaction: Transaction | undefined;
+    loadedWritableAddresses: Uint8Array[];
+    loadedReadonlyAddresses: Uint8Array[];
+}
 export interface SubscribeUpdatePing {
 }
 export interface SubscribeUpdatePong {
     id: number;
 }
+export interface SubscribeUpdateDeshred {
+    filters: string[];
+    deshredTransaction?: SubscribeUpdateDeshredTransaction | undefined;
+    ping?: SubscribeUpdatePing | undefined;
+    pong?: SubscribeUpdatePong | undefined;
+    createdAt: Date | undefined;
+}
 export interface SubscribeReplayInfoRequest {
 }
 export interface SubscribeReplayInfoResponse {
@@ -282,8 +331,11 @@ export declare const SubscribeRequestFilterTransactions: MessageFns<SubscribeReq
 export declare const SubscribeRequestFilterBlocks: MessageFns<SubscribeRequestFilterBlocks>;
 export declare const SubscribeRequestFilterBlocksMeta: MessageFns<SubscribeRequestFilterBlocksMeta>;
 export declare const SubscribeRequestFilterEntry: MessageFns<SubscribeRequestFilterEntry>;
+export declare const SubscribeRequestFilterDeshredTransactions: MessageFns<SubscribeRequestFilterDeshredTransactions>;
 export declare const SubscribeRequestAccountsDataSlice: MessageFns<SubscribeRequestAccountsDataSlice>;
 export declare const SubscribeRequestPing: MessageFns<SubscribeRequestPing>;
+export declare const SubscribeDeshredRequest: MessageFns<SubscribeDeshredRequest>;
+export declare const SubscribeDeshredRequest_DeshredTransactionsEntry: MessageFns<SubscribeDeshredRequest_DeshredTransactionsEntry>;
 export declare const SubscribeUpdate: MessageFns<SubscribeUpdate>;
 export declare const SubscribeUpdateAccount: MessageFns<SubscribeUpdateAccount>;
 export declare const SubscribeUpdateAccountInfo: MessageFns<SubscribeUpdateAccountInfo>;
@@ -294,8 +346,11 @@ export declare const SubscribeUpdateTransactionStatus: MessageFns<SubscribeUpdat
 export declare const SubscribeUpdateBlock: MessageFns<SubscribeUpdateBlock>;
 export declare const SubscribeUpdateBlockMeta: MessageFns<SubscribeUpdateBlockMeta>;
 export declare const SubscribeUpdateEntry: MessageFns<SubscribeUpdateEntry>;
+export declare const SubscribeUpdateDeshredTransaction: MessageFns<SubscribeUpdateDeshredTransaction>;
+export declare const SubscribeUpdateDeshredTransactionInfo: MessageFns<SubscribeUpdateDeshredTransactionInfo>;
 export declare const SubscribeUpdatePing: MessageFns<SubscribeUpdatePing>;
 export declare const SubscribeUpdatePong: MessageFns<SubscribeUpdatePong>;
+export declare const SubscribeUpdateDeshred: MessageFns<SubscribeUpdateDeshred>;
 export declare const SubscribeReplayInfoRequest: MessageFns<SubscribeReplayInfoRequest>;
 export declare const SubscribeReplayInfoResponse: MessageFns<SubscribeReplayInfoResponse>;
 export declare const PingRequest: MessageFns<PingRequest>;

package/dist/types/index.d.ts

@@ -1,30 +1,44 @@
 /** TypeScript/JavaScript client for gRPC Geyser. */
 import { SubscribeUpdateTransactionInfo } from "./grpc/geyser";
+import type { CommitmentLevel, GetBlockHeightResponse, GetLatestBlockhashResponse, GetSlotResponse, GetVersionResponse, IsBlockhashValidResponse, PongResponse, SubscribeReplayInfoResponse, SubscribeRequest } from "./grpc/geyser";
 export { CommitmentLevel, SubscribeRequest, SubscribeRequest_AccountsEntry, SubscribeRequest_BlocksEntry, SubscribeRequest_BlocksMetaEntry, SubscribeRequest_SlotsEntry, SubscribeRequest_TransactionsEntry, SubscribeRequestAccountsDataSlice, SubscribeRequestFilterAccounts, SubscribeRequestFilterAccountsFilter, SubscribeRequestFilterAccountsFilterLamports, SubscribeRequestFilterAccountsFilterMemcmp, SubscribeRequestFilterBlocks, SubscribeRequestFilterBlocksMeta, SubscribeRequestFilterEntry, SubscribeRequestFilterSlots, SubscribeRequestFilterTransactions, SubscribeUpdate, SubscribeUpdateAccount, SubscribeUpdateAccountInfo, SubscribeUpdateBlock, SubscribeUpdateBlockMeta, SubscribeUpdatePing, SubscribeUpdateSlot, SubscribeUpdateTransaction, SubscribeUpdateTransactionInfo, } from "./grpc/geyser";
 import type { TransactionErrorSolana, MapTransactionEncodingToReturnType } from "./types";
 import { Duplex } from "stream";
 import * as napi from "./napi/index";
+/**
+ * Public channel options accepted by the SDK constructor.
+ * This is sourced from the native N-API constructor signature to avoid
+ * duplicating option fields in this file.
+ */
+export type ChannelOptions = NonNullable<Parameters<typeof napi.GrpcClient.new>[2]>;
 export default class Client {
-    _insecureEndpoint: string;
-    _insecureXToken: string | undefined;
-    _channelOptions: napi.JsChannelOptions | undefined;
-    _grpcClient: napi.GrpcClient | null;
-    constructor(endpoint: string, xToken: string | undefined, channel_options: napi.JsChannelOptions | undefined);
+    private _insecureEndpoint;
+    private _insecureXToken;
+    private _channelOptions;
+    private _grpcClient;
+    constructor(endpoint: string, xToken: string | undefined, channel_options: ChannelOptions | undefined);
+    private _connectedGrpcClient;
     connect(): Promise<void>;
-    getLatestBlockhash(commitment?: number): Promise<napi.JsGetLatestBlockhashResponse>;
-    ping(count: number): Promise<number>;
-    getBlockHeight(commitment?: number): Promise<string>;
-    getSlot(commitment?: number): Promise<string>;
-    isBlockhashValid(blockhash: string, commitment?: number): Promise<napi.JsIsBlockhashValidResponse>;
-    getVersion(): Promise<string>;
-    subscribeReplayInfo(): Promise<napi.JsSubscribeReplayInfoResponse>;
+    getLatestBlockhash(commitment?: CommitmentLevel): Promise<GetLatestBlockhashResponse>;
+    ping(count: number): Promise<PongResponse>;
+    getBlockHeight(commitment?: CommitmentLevel): Promise<GetBlockHeightResponse>;
+    getSlot(commitment?: CommitmentLevel): Promise<GetSlotResponse>;
+    isBlockhashValid(blockhash: string, commitment?: CommitmentLevel): Promise<IsBlockhashValidResponse>;
+    getVersion(): Promise<GetVersionResponse>;
+    subscribeReplayInfo(): Promise<SubscribeReplayInfoResponse>;
     subscribe(): Promise<ClientDuplexStream>;
 }
-declare class ClientDuplexStream extends Duplex {
-    _napiDuplexStream: napi.DuplexStream;
-    constructor(stream: napi.DuplexStream, options: object | undefined);
-    _read(_size: number): Promise<void>;
-    _write(chunk: object, _encoding: any, callback: any): void;
+export declare class ClientDuplexStream extends Duplex {
+    private _napiDuplexStream;
+    private _readInFlight;
+    private _isClosed;
+    private _isDestroying;
+    private _terminalErrorSeen;
+    constructor(stream: unknown, options: object | undefined);
+    _pullNextUpdate(): void;
+    _read(_size: number): void;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+    _write(chunk: SubscribeRequest, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
 }
 export declare const txEncode: {
     encoding: any;