@clonegod/ttd-sui-common 1.0.0 → 1.0.3

package/README.md

@@ -0,0 +1,12 @@
+## sur grpc overview
+
+https://github.com/MystenLabs/sui/blob/main/docs/content/concepts/grpc-overview.mdx
+
+### grpc proto
+
+https://github.com/MystenLabs/sui-rust-sdk/tree/master/crates/sui-rpc/vendored/proto/sui/rpc/v2beta2
+
+https://github.com/MystenLabs/sui-apis/tree/main/proto
+
+
+

package/dist/grpc/grpc-connection.d.ts

@@ -0,0 +1,13 @@
+import * as grpc from '@grpc/grpc-js';
+export declare class GrpcConnection {
+    private static instance;
+    private channel;
+    private endpoint;
+    private metadata;
+    private constructor();
+    static getInstance(grpc_endpoint: string, grpc_token: string): GrpcConnection;
+    private getChannel;
+    createServiceClient<T>(protoFileName: string, serviceName: string): T;
+    getMetadata(): grpc.Metadata;
+    close(): void;
+}

package/dist/grpc/grpc-connection.js

@@ -0,0 +1,99 @@
+"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.GrpcConnection = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const path = __importStar(require("path"));
+class GrpcConnection {
+    constructor(grpc_endpoint, grpc_token) {
+        this.channel = null;
+        this.endpoint = grpc_endpoint;
+        this.metadata = new grpc.Metadata();
+        this.metadata.add('x-token', grpc_token);
+    }
+    static getInstance(grpc_endpoint, grpc_token) {
+        if (!GrpcConnection.instance) {
+            GrpcConnection.instance = new GrpcConnection(grpc_endpoint, grpc_token);
+        }
+        return GrpcConnection.instance;
+    }
+    getChannel() {
+        if (!this.channel) {
+            this.channel = new grpc.Channel(this.endpoint, grpc.credentials.createSsl(), {
+                'grpc.keepalive_time_ms': 120000,
+                'grpc.keepalive_timeout_ms': 20000,
+                'grpc.keepalive_permit_without_calls': 0,
+                'grpc.http2.max_pings_without_data': 0,
+                'grpc.http2.min_time_between_pings_ms': 120000,
+                'grpc.http2.min_ping_interval_without_data_ms': 120000
+            });
+            console.log(`创建 gRPC 通道: ${this.endpoint}`);
+        }
+        return this.channel;
+    }
+    createServiceClient(protoFileName, serviceName) {
+        var _a, _b, _c;
+        const protoPath = path.join(__dirname, 'protos/sui/rpc/v2beta2', protoFileName);
+        const packageDefinition = protoLoader.loadSync(protoPath, {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true,
+            includeDirs: [path.join(__dirname, 'protos')]
+        });
+        const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
+        const service = (_c = (_b = (_a = protoDescriptor.sui) === null || _a === void 0 ? void 0 : _a.rpc) === null || _b === void 0 ? void 0 : _b.v2beta2) === null || _c === void 0 ? void 0 : _c[serviceName];
+        if (!service) {
+            throw new Error(`Service ${serviceName} not found in proto file`);
+        }
+        const channel = this.getChannel();
+        return new service(this.endpoint, grpc.credentials.createSsl(), {
+            channelOverride: channel
+        });
+    }
+    getMetadata() {
+        return this.metadata;
+    }
+    close() {
+        if (this.channel) {
+            this.channel.close();
+            this.channel = null;
+            console.log('gRPC 通道已关闭');
+        }
+    }
+}
+exports.GrpcConnection = GrpcConnection;

package/dist/grpc/index.d.ts

@@ -0,0 +1,5 @@
+export { GrpcConnection } from './grpc-connection';
+export { LedgerService } from './ledger-service';
+export { LiveDataService } from './live-data-service';
+export { TransactionService } from './transaction-service';
+export { SubscriptionService } from './subscription-service';

package/dist/grpc/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionService = exports.TransactionService = exports.LiveDataService = exports.LedgerService = exports.GrpcConnection = void 0;
+var grpc_connection_1 = require("./grpc-connection");
+Object.defineProperty(exports, "GrpcConnection", { enumerable: true, get: function () { return grpc_connection_1.GrpcConnection; } });
+var ledger_service_1 = require("./ledger-service");
+Object.defineProperty(exports, "LedgerService", { enumerable: true, get: function () { return ledger_service_1.LedgerService; } });
+var live_data_service_1 = require("./live-data-service");
+Object.defineProperty(exports, "LiveDataService", { enumerable: true, get: function () { return live_data_service_1.LiveDataService; } });
+var transaction_service_1 = require("./transaction-service");
+Object.defineProperty(exports, "TransactionService", { enumerable: true, get: function () { return transaction_service_1.TransactionService; } });
+var subscription_service_1 = require("./subscription-service");
+Object.defineProperty(exports, "SubscriptionService", { enumerable: true, get: function () { return subscription_service_1.SubscriptionService; } });

package/dist/grpc/ledger-service.d.ts

@@ -0,0 +1,12 @@
+import { GrpcConnection } from './grpc-connection';
+export declare class LedgerService {
+    private ledgerClient;
+    private connection;
+    constructor(connection: GrpcConnection);
+    getServiceInfo(): Promise<unknown>;
+    getEpoch(epoch?: number, includeCommittee?: boolean): Promise<unknown>;
+    getCheckpoint(checkpointId?: string): Promise<any>;
+    getObject(objectId: string, readMask?: string[]): Promise<unknown>;
+    batchGetObjects(objectIds: string[], readMask?: string[]): Promise<unknown>;
+    getTransaction(digest: string, readMask?: string[]): Promise<unknown>;
+}

package/dist/grpc/ledger-service.js

@@ -0,0 +1,159 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerService = void 0;
+class LedgerService {
+    constructor(connection) {
+        this.connection = connection;
+        this.ledgerClient = connection.createServiceClient('ledger_service.proto', 'LedgerService');
+    }
+    getServiceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = {};
+                this.ledgerClient.GetServiceInfo(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+    getEpoch(epoch_1) {
+        return __awaiter(this, arguments, void 0, function* (epoch, includeCommittee = false) {
+            return new Promise((resolve, reject) => {
+                const request = {};
+                if (epoch)
+                    request.epoch = epoch;
+                if (!includeCommittee) {
+                    request.read_mask = {
+                        paths: ['epoch']
+                    };
+                }
+                this.ledgerClient.GetEpoch(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+    getCheckpoint(checkpointId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = checkpointId ? { digest: checkpointId } : {};
+                this.ledgerClient.GetCheckpoint(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+    getObject(objectId, readMask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = {
+                    object_id: objectId
+                };
+                if (readMask && readMask.length > 0) {
+                    request.read_mask = {
+                        paths: readMask
+                    };
+                }
+                else {
+                    request.read_mask = {
+                        paths: [
+                            "object_id",
+                            "version",
+                            "digest",
+                            "owner",
+                            "object_type",
+                            "has_public_transfer",
+                            "previous_transaction",
+                            "storage_rebate",
+                            "balance"
+                        ]
+                    };
+                }
+                this.ledgerClient.GetObject(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else {
+                        resolve(response);
+                    }
+                });
+            });
+        });
+    }
+    batchGetObjects(objectIds, readMask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const requests = objectIds.map(id => ({ object_id: id }));
+                const request = { requests };
+                if (readMask && readMask.length > 0) {
+                    request.read_mask = {
+                        paths: readMask
+                    };
+                }
+                else {
+                    request.read_mask = {
+                        paths: [
+                            "object_id",
+                            "version",
+                            "digest",
+                            "owner",
+                            "object_type",
+                            "has_public_transfer",
+                            "previous_transaction",
+                            "storage_rebate",
+                            "balance"
+                        ]
+                    };
+                }
+                this.ledgerClient.BatchGetObjects(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else {
+                        resolve(response);
+                    }
+                });
+            });
+        });
+    }
+    getTransaction(digest, readMask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = { digest };
+                if (readMask && readMask.length > 0) {
+                    request.read_mask = {
+                        paths: readMask
+                    };
+                }
+                else {
+                    request.read_mask = {
+                        paths: ['digest', 'effects.gas_used', 'checkpoint', 'timestamp', 'balance_changes', 'input_objects', 'output_objects']
+                    };
+                }
+                this.ledgerClient.GetTransaction(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+}
+exports.LedgerService = LedgerService;

package/dist/grpc/live-data-service.d.ts

@@ -0,0 +1,10 @@
+import { GrpcConnection } from './grpc-connection';
+export declare class LiveDataService {
+    private liveDataClient;
+    private connection;
+    constructor(connection: GrpcConnection);
+    getBalance(owner: string, coinType: string): Promise<any>;
+    listBalances(owner: string): Promise<unknown>;
+    getCoinInfo(coinType: string): Promise<unknown>;
+    listOwnedObjects(owner: string, limit?: number, readMask?: string[]): Promise<unknown>;
+}

package/dist/grpc/live-data-service.js

@@ -0,0 +1,101 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveDataService = void 0;
+const utils_1 = require("../utils");
+class LiveDataService {
+    constructor(connection) {
+        this.connection = connection;
+        this.liveDataClient = connection.createServiceClient('live_data_service.proto', 'LiveDataService');
+    }
+    getBalance(owner, coinType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!owner) {
+                throw new Error('owner 参数是必需的');
+            }
+            if (!coinType) {
+                coinType = '0x2::sui::SUI';
+            }
+            return new Promise((resolve, reject) => {
+                const request = {
+                    owner: owner,
+                    coin_type: coinType
+                };
+                this.liveDataClient.GetBalance(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+    listBalances(owner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.liveDataClient.ListBalances({ owner }, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+    getCoinInfo(coinType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.liveDataClient.GetCoinInfo({ coin_type: coinType }, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+    listOwnedObjects(owner, limit, readMask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const request = { owner };
+                if (limit)
+                    request.page_size = limit;
+                if (readMask && readMask.length > 0) {
+                    request.read_mask = {
+                        paths: readMask
+                    };
+                }
+                else {
+                    request.read_mask = {
+                        paths: [
+                            "object_id",
+                            "version",
+                            "digest",
+                            "owner",
+                            "object_type",
+                            "storage_rebate",
+                            "balance"
+                        ]
+                    };
+                }
+                this.liveDataClient.ListOwnedObjects(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else {
+                        let res = (0, utils_1.decodeBytes)(response);
+                        resolve(res);
+                    }
+                });
+            });
+        });
+    }
+}
+exports.LiveDataService = LiveDataService;

package/dist/grpc/subscription-service.d.ts

@@ -0,0 +1,7 @@
+import { GrpcConnection } from './grpc-connection';
+export declare class SubscriptionService {
+    private subscriptionClient;
+    private connection;
+    constructor(connection: GrpcConnection);
+    subscribeCheckpoints(onCheckpoint: (response: any) => void, onError: (error: any) => void, readMask?: string[]): any;
+}

package/dist/grpc/subscription-service.js

@@ -0,0 +1,63 @@
+"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.SubscriptionService = void 0;
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+class SubscriptionService {
+    constructor(connection) {
+        this.connection = connection;
+        this.subscriptionClient = connection.createServiceClient('subscription_service.proto', 'SubscriptionService');
+    }
+    subscribeCheckpoints(onCheckpoint, onError, readMask) {
+        const request = {};
+        if (readMask && readMask.length > 0) {
+            request.read_mask = { paths: readMask };
+        }
+        const stream = this.subscriptionClient.SubscribeCheckpoints(request, this.connection.getMetadata());
+        stream.on('data', (response) => {
+            onCheckpoint(response);
+        });
+        stream.on('error', (error) => {
+            console.error('订阅检查点流错误:', error);
+            onError(error);
+        });
+        stream.on('end', () => {
+            console.log('检查点流订阅结束');
+        });
+        return stream;
+    }
+}
+exports.SubscriptionService = SubscriptionService;

package/dist/grpc/transaction-service.d.ts

@@ -0,0 +1,7 @@
+import { GrpcConnection } from './grpc-connection';
+export declare class TransactionService {
+    private transactionClient;
+    private connection;
+    constructor(connection: GrpcConnection);
+    executeTransaction(serializedTransaction: string, signatureBytes: string, publickeyBytes: string, fields?: string[]): Promise<unknown>;
+}

package/dist/grpc/transaction-service.js

@@ -0,0 +1,48 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+class TransactionService {
+    constructor(connection) {
+        this.connection = connection;
+        this.transactionClient = connection.createServiceClient('transaction_execution_service.proto', 'TransactionExecutionService');
+    }
+    executeTransaction(serializedTransaction_1, signatureBytes_1, publickeyBytes_1) {
+        return __awaiter(this, arguments, void 0, function* (serializedTransaction, signatureBytes, publickeyBytes, fields = ['transaction', 'finality']) {
+            return new Promise((resolve, reject) => {
+                const request = {
+                    transaction: {
+                        bcs: {
+                            bytes: Buffer.from(serializedTransaction, 'base64')
+                        }
+                    },
+                    signatures: [
+                        {
+                            scheme: 0,
+                            signature: Buffer.from(signatureBytes, 'base64'),
+                            public_key: Buffer.from(publickeyBytes, 'base64')
+                        }
+                    ],
+                    read_mask: {
+                        paths: fields
+                    }
+                };
+                this.transactionClient.ExecuteTransaction(request, this.connection.getMetadata(), (error, response) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(response);
+                });
+            });
+        });
+    }
+}
+exports.TransactionService = TransactionService;

package/dist/index.js

@@ -1 +1 @@
-console.log('hello sui');
+console.log('ttd-sui-common');

package/dist/rpc/account-api.d.ts

@@ -0,0 +1,14 @@
+import { RpcConnection } from './rpc-connection';
+export declare class AccountApi {
+    private connection;
+    constructor(connection: RpcConnection);
+    getBalance(owner: string, coinType?: string): Promise<any>;
+    getAllBalances(owner: string): Promise<any>;
+    getAllCoins(owner: string, cursor?: string, limit?: number): Promise<any>;
+    getAllCoinsComplete(owner: string, limit?: number): Promise<any[]>;
+    getCoins(owner: string, coinType: string, cursor?: string, limit?: number): Promise<any>;
+    getCoinsComplete(owner: string, coinType: string, limit?: number): Promise<any[]>;
+    getOwnedObjects(owner: string, filter?: any, cursor?: string, limit?: number): Promise<any>;
+    getAllOwnedObjects(owner: string, filter?: any, limit?: number): Promise<any[]>;
+    getCoinMetadata(coinType: string): Promise<any>;
+}