@clonegod/ttd-sui-common 1.0.34 → 1.0.36

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export * from './grpc';
 export * from './utils';
 export * from './constants';
 export * from './trade';
+export * from './redis';

package/dist/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./grpc"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./trade"), exports);
+__exportStar(require("./redis"), exports);

package/dist/trade/abstract_sui_dex_trade_plus.d.ts

@@ -0,0 +1,32 @@
+import { AbastrcatTrade, AppConfig, TradeContext } from "@clonegod/ttd-core/dist";
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { SuiClient } from "@mysten/sui/client";
+import { SuiGrpcClient, SuiTxSender } from '../index';
+import { SimpleRedisClient } from '../redis';
+export declare abstract class AbstractSuiDexTradePlus extends AbastrcatTrade {
+    protected appConfig: AppConfig;
+    protected group_wallets: Ed25519Keypair[];
+    protected wallet: Ed25519Keypair;
+    protected walletMode: 'single' | 'multi';
+    sui_client: SuiClient;
+    grpcClient: SuiGrpcClient;
+    transactionSender: SuiTxSender;
+    protected redisClient: SimpleRedisClient;
+    walletAddresses: string[];
+    currentWalletAddress: string;
+    protected chainNameLower: string;
+    constructor(appConfig: AppConfig, grpcClient: SuiGrpcClient);
+    private initSuiClient;
+    init(): Promise<void>;
+    protected getWalletMode(): 'single' | 'multi';
+    protected getSingleWallet(): Ed25519Keypair;
+    protected getGroupWallets(): Ed25519Keypair[];
+    protected getWalletAddresses(): string[];
+    protected chooseWallet(context: TradeContext): Promise<Ed25519Keypair>;
+    protected determineInputOutputTokens(order_msg: any, pool_info: any): {
+        inputToken: any;
+        outputToken: any;
+    };
+    abstract execute(context: TradeContext, retryCount?: number): Promise<string>;
+    protected abstract initConfigs(): void;
+}

package/dist/trade/abstract_sui_dex_trade_plus.js

@@ -0,0 +1,216 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSuiDexTradePlus = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
+const client_1 = require("@mysten/sui/client");
+const index_1 = require("../index");
+const redis_1 = require("../redis");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+class AbstractSuiDexTradePlus extends dist_1.AbastrcatTrade {
+    constructor(appConfig, grpcClient) {
+        super();
+        this.appConfig = appConfig;
+        this.walletMode = 'multi';
+        this.walletAddresses = [];
+        this.currentWalletAddress = '';
+        this.grpcClient = grpcClient;
+        this.initConfigs();
+        this.chainNameLower = this.appConfig.env_args.chain_id.toLowerCase();
+        this.redisClient = new redis_1.SimpleRedisClient(`${this.chainNameLower}:tx`);
+    }
+    initSuiClient() {
+        const sui_rpc_url = process.env.SUI_RPC_URL || 'https://fullnode.mainnet.sui.io:443';
+        this.sui_client = new client_1.SuiClient({ url: sui_rpc_url });
+        (0, dist_1.log_info)(`Sui客户端已初始化: ${sui_rpc_url}`);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.initSuiClient();
+            const walletGroupIds = process.env.SUI_WALLET_GROUP_IDS || '';
+            this.walletMode = walletGroupIds && walletGroupIds.trim().split(',').length > 0 ? 'multi' : 'single';
+            if (this.walletMode === 'multi') {
+                let wallet_infos = (0, dist_1.load_wallet_multi)(walletGroupIds.split(','), false);
+                this.group_wallets = wallet_infos.map(info => ed25519_1.Ed25519Keypair.fromSecretKey(info.private_key));
+                this.walletAddresses = this.group_wallets.map(keypair => keypair.getPublicKey().toSuiAddress());
+                (0, dist_1.log_info)(`组钱包已初始化，数量: ${this.group_wallets.length}`, this.walletAddresses);
+            }
+            else {
+                const { private_key } = this.appConfig.trade_runtime.wallet;
+                this.wallet = ed25519_1.Ed25519Keypair.fromSecretKey(private_key);
+                this.currentWalletAddress = this.wallet.getPublicKey().toSuiAddress();
+                this.walletAddresses = [this.currentWalletAddress];
+                (0, dist_1.log_info)(`单钱包已初始化，walletAddress= ${this.currentWalletAddress}`);
+            }
+            this.transactionSender = new index_1.SuiTxSender(this.appConfig, this.sui_client, this.grpcClient);
+        });
+    }
+    getWalletMode() {
+        return this.walletMode;
+    }
+    getSingleWallet() {
+        if (this.walletMode !== 'single' || !this.wallet) {
+            throw new Error('Single wallet not available in multi-wallet mode or not initialized');
+        }
+        return this.wallet;
+    }
+    getGroupWallets() {
+        if (this.walletMode !== 'multi' || !this.group_wallets) {
+            throw new Error('Group wallets not available in single-wallet mode or not initialized');
+        }
+        return this.group_wallets;
+    }
+    getWalletAddresses() {
+        return this.walletAddresses;
+    }
+    chooseWallet(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.getWalletMode() === 'single') {
+                return this.getSingleWallet();
+            }
+            const { inputToken } = this.determineInputOutputTokens(context.order_msg, context.pool_info);
+            console.log('inputToken', inputToken);
+            const requiredAmount = new decimal_js_1.default(context.order_msg.amount);
+            const wallet_assets = yield this.redisClient.hgetall('sui:wallet:assets');
+            if (!wallet_assets || Object.keys(wallet_assets).length === 0) {
+                throw new Error('没有找到钱包资产信息，请确保钱包监控服务正在运行');
+            }
+            const wallet_assets_map = {};
+            for (const [walletAddress, assetsJson] of Object.entries(wallet_assets)) {
+                try {
+                    wallet_assets_map[walletAddress] = JSON.parse(assetsJson);
+                }
+                catch (error) {
+                    console.warn(`解析钱包资产数据失败: ${walletAddress}`, error);
+                }
+            }
+            const availableWallets = [];
+            const allWallets = [];
+            for (const [walletAddress, assets] of Object.entries(wallet_assets_map)) {
+                try {
+                    const wallet = (_a = this.group_wallets) === null || _a === void 0 ? void 0 : _a.find(w => w.getPublicKey().toSuiAddress().toLowerCase() === walletAddress.toLowerCase());
+                    if (!wallet) {
+                        continue;
+                    }
+                    const tokenAsset = (_b = assets.tokens) === null || _b === void 0 ? void 0 : _b.find((token) => token.tokenaddr.toLowerCase() === inputToken.address.toLowerCase());
+                    let tokenBalance = (tokenAsset === null || tokenAsset === void 0 ? void 0 : tokenAsset.balance) || '0';
+                    const balanceDecimal = new decimal_js_1.default(tokenBalance);
+                    if (balanceDecimal.gte(requiredAmount)) {
+                        availableWallets.push({
+                            wallet,
+                            balance: tokenBalance
+                        });
+                    }
+                    else {
+                        console.log(`钱包 ${walletAddress} 余额不足: ${tokenBalance} ${inputToken.symbol} < ${requiredAmount} ${inputToken.symbol}`);
+                    }
+                    allWallets.push({
+                        wallet,
+                        balance: tokenBalance
+                    });
+                }
+                catch (error) {
+                    console.warn(`处理钱包资产时出错: ${walletAddress}`, error);
+                }
+            }
+            if (availableWallets.length === 0) {
+                let error_msg = `all wallets are insufficient, required: ${requiredAmount} ${inputToken.symbol}`;
+                (0, dist_1.log_warn)(error_msg);
+                allWallets.forEach((walletInfo, index) => {
+                    const walletAddress = walletInfo.wallet.getPublicKey().toSuiAddress();
+                    const shortAddress = walletAddress.substring(0, 6) + '...' + walletAddress.substring(walletAddress.length - 4);
+                    console.log(`${index + 1}. ${shortAddress}: ${walletInfo.balance} ${inputToken.symbol}`);
+                });
+                throw new Error(error_msg);
+            }
+            console.log('availableWallets', availableWallets.map(w => w.wallet.getPublicKey().toSuiAddress()));
+            const wallet_last_used = yield this.redisClient.hgetall('sui:wallet:last_used');
+            for (const availableWallet of availableWallets) {
+                const walletAddress = availableWallet.wallet.getPublicKey().toSuiAddress();
+                const lastUsedData = wallet_last_used === null || wallet_last_used === void 0 ? void 0 : wallet_last_used[walletAddress];
+                if (lastUsedData) {
+                    try {
+                        const lastUsedInfo = JSON.parse(lastUsedData);
+                        availableWallet.lastUsedAt = lastUsedInfo.lastUsedAt;
+                    }
+                    catch (error) {
+                        console.warn(`解析钱包最后使用时间失败: ${walletAddress}`, error);
+                    }
+                }
+                else {
+                    yield this.redisClient.hsetValue('sui:wallet:last_used', walletAddress, JSON.stringify({
+                        lastUsedAt: 0,
+                        lastUsedTime: new Date(0).toISOString()
+                    }), 24 * 60 * 60);
+                    availableWallet.lastUsedAt = 0;
+                }
+            }
+            let selectedWallet;
+            let selectionStrategy;
+            if (availableWallets.length === 1) {
+                selectedWallet = availableWallets[0].wallet;
+                selectionStrategy = 'OnlyOne';
+            }
+            else {
+                const hasUsageHistory = wallet_last_used && Object.keys(wallet_last_used).length > 0;
+                if (hasUsageHistory) {
+                    availableWallets.sort((a, b) => {
+                        const aTime = a.lastUsedAt || 0;
+                        const bTime = b.lastUsedAt || 0;
+                        return aTime - bTime;
+                    });
+                    selectedWallet = availableWallets[0].wallet;
+                    selectionStrategy = 'MaxLastUsed';
+                }
+                else {
+                    availableWallets.sort((a, b) => {
+                        const aBalance = new decimal_js_1.default(a.balance);
+                        const bBalance = new decimal_js_1.default(b.balance);
+                        return bBalance.cmp(aBalance);
+                    });
+                    selectedWallet = availableWallets[0].wallet;
+                    selectionStrategy = 'MaxBalance';
+                }
+            }
+            const selectedWalletAddress = selectedWallet.getPublicKey().toSuiAddress();
+            yield this.redisClient.hsetValue('sui:wallet:last_used', selectedWalletAddress, JSON.stringify({
+                lastUsedAt: Date.now(),
+                lastUsedTime: new Date().toISOString()
+            }), 24 * 60 * 60);
+            const selectedWalletInfo = availableWallets.find(w => w.wallet.getPublicKey().toSuiAddress() === selectedWalletAddress);
+            (0, dist_1.log_info)(`Choose wallet: ${selectionStrategy} -> ${selectedWalletAddress}, balance: ${selectedWalletInfo === null || selectedWalletInfo === void 0 ? void 0 : selectedWalletInfo.balance} ${inputToken.symbol}, required: ${requiredAmount} ${inputToken.symbol}`);
+            return selectedWallet;
+        });
+    }
+    determineInputOutputTokens(order_msg, pool_info) {
+        const { aToB } = order_msg;
+        const { tokenA, tokenB, quote_token } = pool_info;
+        const quoteToken = [tokenA, tokenB].find(token => token.symbol === quote_token);
+        const nonQuoteToken = [tokenA, tokenB].find(token => token.symbol !== quote_token);
+        const inputToken = aToB ? nonQuoteToken : quoteToken;
+        const outputToken = aToB ? quoteToken : nonQuoteToken;
+        if (!inputToken || !outputToken) {
+            throw new Error(`无法确定输入/输出代币: ${JSON.stringify({
+                tokenA: tokenA.symbol,
+                tokenB: tokenB.symbol,
+                quote: quote_token,
+                aToB
+            })}`);
+        }
+        return { inputToken, outputToken };
+    }
+}
+exports.AbstractSuiDexTradePlus = AbstractSuiDexTradePlus;

package/dist/trade/index.d.ts

@@ -1,3 +1,4 @@
 export * from './send_tx';
 export * from './check';
 export * from './parse';
+export * from './abstract_sui_dex_trade_plus';

package/dist/trade/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./send_tx"), exports);
 __exportStar(require("./check"), exports);
 __exportStar(require("./parse"), exports);
+__exportStar(require("./abstract_sui_dex_trade_plus"), exports);

package/dist/ttd-sui-common/src/constants/index.d.ts

@@ -0,0 +1,4 @@
+export declare enum SUI_TOKEN_ADDRESS {
+    SHORT = "0x2::sui::SUI",
+    LONG = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
+}

package/dist/ttd-sui-common/src/constants/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUI_TOKEN_ADDRESS = void 0;
+var SUI_TOKEN_ADDRESS;
+(function (SUI_TOKEN_ADDRESS) {
+    SUI_TOKEN_ADDRESS["SHORT"] = "0x2::sui::SUI";
+    SUI_TOKEN_ADDRESS["LONG"] = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+})(SUI_TOKEN_ADDRESS || (exports.SUI_TOKEN_ADDRESS = SUI_TOKEN_ADDRESS = {}));

package/dist/ttd-sui-common/src/grpc/gas-price-cache.d.ts

@@ -0,0 +1,21 @@
+export declare class GasPriceCache {
+    private static instance;
+    private cachedGasPrice;
+    private lastUpdateTime;
+    private updateInterval;
+    private ledgerService;
+    private refreshTimer?;
+    private constructor();
+    static getInstance(ledgerService: any): GasPriceCache;
+    getGasPrice(): Promise<number>;
+    refreshGasPrice(): Promise<void>;
+    private startAutoRefresh;
+    stopAutoRefresh(): void;
+    getCacheInfo(): {
+        cachedGasPrice: number;
+        lastUpdateTime: number;
+        isExpired: boolean;
+        timeUntilNextRefresh: number;
+    };
+    destroy(): void;
+}

package/dist/ttd-sui-common/src/grpc/gas-price-cache.js

@@ -0,0 +1,83 @@
+"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.GasPriceCache = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class GasPriceCache {
+    constructor(ledgerService) {
+        this.cachedGasPrice = 0;
+        this.lastUpdateTime = 0;
+        this.updateInterval = 60 * 60 * 1000;
+        this.ledgerService = ledgerService;
+        this.startAutoRefresh();
+    }
+    static getInstance(ledgerService) {
+        if (!GasPriceCache.instance) {
+            GasPriceCache.instance = new GasPriceCache(ledgerService);
+        }
+        return GasPriceCache.instance;
+    }
+    getGasPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Date.now() - this.lastUpdateTime > this.updateInterval || this.cachedGasPrice === 0) {
+                yield this.refreshGasPrice();
+            }
+            return this.cachedGasPrice;
+        });
+    }
+    refreshGasPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const epochRes = yield this.ledgerService.getEpoch();
+                this.cachedGasPrice = Number(epochRes['epoch']['reference_gas_price']);
+                this.lastUpdateTime = Date.now();
+                (0, dist_1.log_info)(`refreshGasPrice success: ${this.cachedGasPrice} MIST`);
+            }
+            catch (error) {
+                (0, dist_1.log_error)('refresh gas price failed', error);
+                this.cachedGasPrice = Number(process.env.DEFAULT_GAS_PRICE || '600');
+            }
+        });
+    }
+    startAutoRefresh() {
+        this.refreshGasPrice().catch(error => {
+            (0, dist_1.log_error)('initial gas price refresh failed', error);
+        });
+        this.refreshTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshGasPrice();
+        }), this.updateInterval);
+        (0, dist_1.log_info)('Gas price auto refresh started, refresh interval: 5 minutes');
+    }
+    stopAutoRefresh() {
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = undefined;
+            (0, dist_1.log_info)('Gas price auto refresh stopped');
+        }
+    }
+    getCacheInfo() {
+        const now = Date.now();
+        const timeSinceLastUpdate = now - this.lastUpdateTime;
+        const isExpired = timeSinceLastUpdate > this.updateInterval;
+        const timeUntilNextRefresh = Math.max(0, this.updateInterval - timeSinceLastUpdate);
+        return {
+            cachedGasPrice: this.cachedGasPrice,
+            lastUpdateTime: this.lastUpdateTime,
+            isExpired,
+            timeUntilNextRefresh
+        };
+    }
+    destroy() {
+        this.stopAutoRefresh();
+        GasPriceCache.instance = null;
+    }
+}
+exports.GasPriceCache = GasPriceCache;

package/dist/ttd-sui-common/src/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/ttd-sui-common/src/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/ttd-sui-common/src/grpc/index.d.ts

@@ -0,0 +1,7 @@
+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';
+export { SuiGrpcClient } from './sui-grpc-client';
+export { GasPriceCache } from './gas-price-cache';

package/dist/ttd-sui-common/src/grpc/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GasPriceCache = exports.SuiGrpcClient = 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; } });
+var sui_grpc_client_1 = require("./sui-grpc-client");
+Object.defineProperty(exports, "SuiGrpcClient", { enumerable: true, get: function () { return sui_grpc_client_1.SuiGrpcClient; } });
+var gas_price_cache_1 = require("./gas-price-cache");
+Object.defineProperty(exports, "GasPriceCache", { enumerable: true, get: function () { return gas_price_cache_1.GasPriceCache; } });

package/dist/ttd-sui-common/src/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, includeGasPrice?: 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>;
+}