@triton-one/yellowstone-grpc 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TypeScript/JavaScript client for gRPC Geyser.
+ */
+import { CommitmentLevel, GetLatestBlockhashResponse, GeyserClient, IsBlockhashValidResponse, SubscribeRequestFilterAccounts, SubscribeRequestFilterBlocks, SubscribeRequestFilterBlocksMeta, SubscribeRequestFilterSlots, SubscribeRequestFilterTransactions } from "./grpc/geyser";
+export { SubscribeRequest, SubscribeRequest_AccountsEntry, SubscribeRequest_SlotsEntry, SubscribeRequestFilterSlots, SubscribeRequest_TransactionsEntry, SubscribeRequestFilterTransactions, SubscribeRequest_BlocksEntry, SubscribeRequest_BlocksMetaEntry, SubscribeRequestFilterAccounts, SubscribeRequestFilterAccountsFilter, SubscribeRequestFilterAccountsFilterMemcmp, SubscribeRequestFilterBlocks, SubscribeRequestFilterBlocksMeta, SubscribeUpdate, SubscribeUpdateAccount, SubscribeUpdateAccountInfo, SubscribeUpdateSlot, CommitmentLevel, SubscribeUpdateTransaction, SubscribeUpdateTransactionInfo, SubscribeUpdateBlock, SubscribeUpdatePing, SubscribeUpdateBlockMeta, } from "./grpc/geyser";
+export default class Client {
+    _client: GeyserClient;
+    constructor(endpoint: string, xToken: string | undefined);
+    subscribe(): Promise<import("@grpc/grpc-js").ClientDuplexStream<import("./grpc/geyser").SubscribeRequest, import("./grpc/geyser").SubscribeUpdate>>;
+    subscribe_once(accounts: {
+        [key: string]: SubscribeRequestFilterAccounts;
+    }, slots: {
+        [key: string]: SubscribeRequestFilterSlots;
+    }, transactions: {
+        [key: string]: SubscribeRequestFilterTransactions;
+    }, blocks: {
+        [key: string]: SubscribeRequestFilterBlocks;
+    }, blocksMeta: {
+        [key: string]: SubscribeRequestFilterBlocksMeta;
+    }, commitment?: CommitmentLevel | undefined): Promise<import("@grpc/grpc-js").ClientDuplexStream<import("./grpc/geyser").SubscribeRequest, import("./grpc/geyser").SubscribeUpdate>>;
+    ping(count: number): Promise<number>;
+    getLatestBlockhash(commitment?: CommitmentLevel): Promise<GetLatestBlockhashResponse>;
+    getBlockHeight(commitment?: CommitmentLevel): Promise<number>;
+    getSlot(commitment?: CommitmentLevel): Promise<number>;
+    isBlockhashValid(blockhash: string, commitment?: CommitmentLevel): Promise<IsBlockhashValidResponse>;
+    getVersion(): Promise<string>;
+}

package/dist/index.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * TypeScript/JavaScript client for gRPC Geyser.
+ */
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.SubscribeUpdateBlockMeta = exports.SubscribeUpdatePing = exports.SubscribeUpdateBlock = exports.SubscribeUpdateTransactionInfo = exports.SubscribeUpdateTransaction = exports.CommitmentLevel = exports.SubscribeUpdateSlot = exports.SubscribeUpdateAccountInfo = exports.SubscribeUpdateAccount = exports.SubscribeUpdate = exports.SubscribeRequestFilterBlocksMeta = exports.SubscribeRequestFilterBlocks = exports.SubscribeRequestFilterAccountsFilterMemcmp = exports.SubscribeRequestFilterAccountsFilter = exports.SubscribeRequestFilterAccounts = exports.SubscribeRequest_BlocksMetaEntry = exports.SubscribeRequest_BlocksEntry = exports.SubscribeRequestFilterTransactions = exports.SubscribeRequest_TransactionsEntry = exports.SubscribeRequestFilterSlots = exports.SubscribeRequest_SlotsEntry = exports.SubscribeRequest_AccountsEntry = exports.SubscribeRequest = void 0;
+// Import generated gRPC client and types.
+var geyser_1 = require("./grpc/geyser");
+var grpc_js_1 = require("@grpc/grpc-js");
+// Reexport automatically generated types
+var geyser_2 = require("./grpc/geyser");
+__createBinding(exports, geyser_2, "SubscribeRequest");
+__createBinding(exports, geyser_2, "SubscribeRequest_AccountsEntry");
+__createBinding(exports, geyser_2, "SubscribeRequest_SlotsEntry");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterSlots");
+__createBinding(exports, geyser_2, "SubscribeRequest_TransactionsEntry");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterTransactions");
+__createBinding(exports, geyser_2, "SubscribeRequest_BlocksEntry");
+__createBinding(exports, geyser_2, "SubscribeRequest_BlocksMetaEntry");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterAccounts");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterAccountsFilter");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterAccountsFilterMemcmp");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterBlocks");
+__createBinding(exports, geyser_2, "SubscribeRequestFilterBlocksMeta");
+__createBinding(exports, geyser_2, "SubscribeUpdate");
+__createBinding(exports, geyser_2, "SubscribeUpdateAccount");
+__createBinding(exports, geyser_2, "SubscribeUpdateAccountInfo");
+__createBinding(exports, geyser_2, "SubscribeUpdateSlot");
+__createBinding(exports, geyser_2, "CommitmentLevel");
+__createBinding(exports, geyser_2, "SubscribeUpdateTransaction");
+__createBinding(exports, geyser_2, "SubscribeUpdateTransactionInfo");
+__createBinding(exports, geyser_2, "SubscribeUpdateBlock");
+__createBinding(exports, geyser_2, "SubscribeUpdatePing");
+__createBinding(exports, geyser_2, "SubscribeUpdateBlockMeta");
+var Client = /** @class */ (function () {
+    function Client(endpoint, xToken) {
+        var creds;
+        var endpointURL = new URL(endpoint);
+        // Check if we need to use TLS.
+        if (endpointURL.protocol === "https:") {
+            creds = grpc_js_1.credentials.combineChannelCredentials(grpc_js_1.credentials.createSsl(), grpc_js_1.credentials.createFromMetadataGenerator(function (_params, callback) {
+                var metadata = new grpc_js_1.Metadata();
+                if (xToken !== undefined) {
+                    metadata.add("x-token", xToken);
+                }
+                return callback(null, metadata);
+            }));
+        }
+        else {
+            creds = grpc_js_1.ChannelCredentials.createInsecure();
+        }
+        this._client = new geyser_1.GeyserClient(endpointURL.host, creds);
+    }
+    Client.prototype.subscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._client.subscribe()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.subscribe_once = function (accounts, slots, transactions, blocks, blocksMeta, commitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stream;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._client.subscribe()];
+                    case 1:
+                        stream = _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                stream.write({
+                                    accounts: accounts,
+                                    slots: slots,
+                                    transactions: transactions,
+                                    blocks: blocks,
+                                    blocksMeta: blocksMeta,
+                                    commitment: commitment
+                                }, function (err) {
+                                    if (err === null || err === undefined) {
+                                        resolve();
+                                    }
+                                    else {
+                                        reject(err);
+                                    }
+                                });
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, stream];
+                }
+            });
+        });
+    };
+    Client.prototype.ping = function (count) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            _this._client.ping({ count: count }, function (err, response) {
+                                if (err === null || err === undefined) {
+                                    resolve(response.count);
+                                }
+                                else {
+                                    reject(err);
+                                }
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.getLatestBlockhash = function (commitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            _this._client.getLatestBlockhash({ commitment: commitment }, function (err, response) {
+                                if (err === null || err === undefined) {
+                                    resolve(response);
+                                }
+                                else {
+                                    reject(err);
+                                }
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.getBlockHeight = function (commitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            _this._client.getBlockHeight({ commitment: commitment }, function (err, response) {
+                                if (err === null || err === undefined) {
+                                    resolve(response.blockHeight);
+                                }
+                                else {
+                                    reject(err);
+                                }
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.getSlot = function (commitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            _this._client.getSlot({ commitment: commitment }, function (err, response) {
+                                if (err === null || err === undefined) {
+                                    resolve(response.slot);
+                                }
+                                else {
+                                    reject(err);
+                                }
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.isBlockhashValid = function (blockhash, commitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            _this._client.isBlockhashValid({ blockhash: blockhash, commitment: commitment }, function (err, response) {
+                                if (err === null || err === undefined) {
+                                    resolve(response);
+                                }
+                                else {
+                                    reject(err);
+                                }
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Client.prototype.getVersion = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            _this._client.getVersion({}, function (err, response) {
+                                if (err === null || err === undefined) {
+                                    resolve(response.version);
+                                }
+                                else {
+                                    reject(err);
+                                }
+                            });
+                        })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return Client;
+}());
+exports["default"] = Client;

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@triton-one/yellowstone-grpc",
+    "version": "0.1.0",
+    "license": "Apache-2.0",
+    "author": "Triton One",
+    "description": "Yellowstone gRPC Geyser Node.js Client",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "npm run grpc-generate && tsc -p .",
+        "grpc-generate": "protoc -I../yellowstone-grpc-proto/proto --plugin=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_opt=outputServices=grpc-js --ts_proto_out=./src/grpc geyser.proto"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/rpcpool/yellowstone-grpc.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "bugs": {
+        "url": "https://github.com/rpcpool/yellowstone-grpc/issues"
+    },
+    "keywords": [
+        "solana"
+    ],
+    "homepage": "https://triton.one",
+    "dependencies": {
+        "@grpc/grpc-js": "^1.8.0"
+    },
+    "devDependencies": {
+        "prettier": "2.8.3",
+        "ts-proto": "^1.139.0",
+        "typescript": "^4.9.5"
+    }
+}