@clonegod/ttd-sui-common 1.0.34 → 1.0.36

package/dist/ttd-sui-common/src/redis/redis_client.js

@@ -0,0 +1,155 @@
+"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.SimpleRedisClient = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class SimpleRedisClient {
+    constructor(lock_prefix) {
+        this.lock_prefix = lock_prefix;
+        this.redisClient = null;
+        this.lockMaxRetries = 10;
+        this.lockRetryDelayMs = 300;
+        this.lockExpireSeconds = 3;
+    }
+    getRedisClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redisClient) {
+                this.redisClient = yield (0, dist_1.getRedisCache)();
+            }
+            return this.redisClient;
+        });
+    }
+    getLockKey(lock_identifier) {
+        return `${this.lock_prefix}:lock:${lock_identifier}`;
+    }
+    acquireLock(lock_key_1, lock_value_1) {
+        return __awaiter(this, arguments, void 0, function* (lock_key, lock_value, expireSeconds = this.lockExpireSeconds) {
+            const redisClient = yield this.getRedisClient();
+            const result = yield redisClient.set(lock_key, lock_value, {
+                NX: true,
+                EX: expireSeconds
+            });
+            (0, dist_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
+            const success = result === 'OK';
+            if (success) {
+                (0, dist_1.log_info)(`acquire lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
+            }
+            return success;
+        });
+    }
+    releaseLock(lock_key, lock_value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            const script = `
+            if redis.call('get', KEYS[1]) == ARGV[1] then
+                return redis.call('del', KEYS[1])
+            else
+                return 0
+            end
+        `;
+            const result = yield redisClient.eval(script, {
+                keys: [lock_key],
+                arguments: [lock_value]
+            });
+            const success = Number(result) === 1;
+            if (success) {
+                (0, dist_1.log_info)(`release lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
+            }
+            else {
+                (0, dist_1.log_info)(`release lock failed: lock_key=${lock_key}, lock_value=${lock_value}, maybe expired or locked by other process`);
+            }
+            return success;
+        });
+    }
+    withLock(lock_identifier_1, callback_1) {
+        return __awaiter(this, arguments, void 0, function* (lock_identifier, callback, release_lock_delay_ms = 2000) {
+            const lock_key = this.getLockKey(lock_identifier);
+            const lock_value = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+            let retries = 0;
+            let acquired = false;
+            let first_try_time = Date.now();
+            let get_lock_time = 0;
+            try {
+                while (retries < this.lockMaxRetries) {
+                    acquired = yield this.acquireLock(lock_key, lock_value);
+                    if (acquired)
+                        break;
+                    yield new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
+                    retries++;
+                }
+                if (acquired) {
+                    get_lock_time = Date.now();
+                    return yield callback();
+                }
+            }
+            finally {
+                if (acquired) {
+                    const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
+                    yield (0, dist_1.sleep)(release_delay);
+                    yield this.releaseLock(lock_key, lock_value);
+                    (0, dist_1.log_info)(`withLock success: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, get lock take ${get_lock_time - first_try_time}ms, release_delay=${release_delay}ms, hold lock ${Date.now() - get_lock_time}ms`);
+                }
+                else {
+                    (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, took ${Date.now() - first_try_time}ms`);
+                }
+            }
+        });
+    }
+    getValue(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.get(key);
+        });
+    }
+    setValue(key, value, expireSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.set(key, value, {
+                EX: expireSeconds
+            });
+        });
+    }
+    hsetValue(key, field, value, expireSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            yield redisClient.hSet(key, field, value);
+            yield redisClient.hExpire(key, field, expireSeconds);
+        });
+    }
+    hgetvalue(key, field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.hGet(key, field);
+        });
+    }
+    hkeys(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.hKeys(key);
+        });
+    }
+    hgetall(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.hGetAll(key);
+        });
+    }
+    del(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, field = '') {
+            const redisClient = yield this.getRedisClient();
+            if (field) {
+                return yield redisClient.hDel(key, field);
+            }
+            return yield redisClient.del(key);
+        });
+    }
+}
+exports.SimpleRedisClient = SimpleRedisClient;

package/dist/ttd-sui-common/src/test/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ttd-sui-common/src/test/test.js

@@ -0,0 +1,126 @@
+"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 });
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const path = __importStar(require("path"));
+const PROTO_PATH = path.join(__dirname, 'protos/sui/rpc/v2beta2/ledger_service.proto');
+const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+    includeDirs: [path.join(__dirname, 'protos')],
+});
+const suiProto = grpc.loadPackageDefinition(packageDefinition);
+const LedgerService = suiProto.sui.rpc.v2beta2.LedgerService;
+const endpoint = process.env.SUI_GRPC_ENDPOINT;
+const token = process.env.SUI_GRPC_TOKEN;
+if (!endpoint || !token) {
+    throw new Error('SUI_GRPC_ENDPOINT and SUI_GRPC_TOKEN must be set');
+}
+const client = new LedgerService(endpoint, grpc.credentials.createSsl(), {
+    'grpc.keepalive_time_ms': 30000,
+    'grpc.keepalive_timeout_ms': 5000,
+    'grpc.keepalive_permit_without_calls': true,
+    'grpc.http2.max_pings_without_data': 0,
+    'grpc.http2.min_time_between_pings_ms': 10000,
+    'grpc.http2.min_ping_interval_without_data_ms': 300000
+});
+const metadata = new grpc.Metadata();
+metadata.add('x-token', token);
+const suiSystemPackageId = '0x0000000000000000000000000000000000000000000000000000000000000002';
+const request = {
+    object_id: suiSystemPackageId,
+    read_mask: {
+        paths: [
+            'object_id',
+            'version',
+            'digest',
+            'owner',
+            'object_type',
+            'has_public_transfer',
+            'previous_transaction',
+            'storage_rebate'
+        ],
+    },
+};
+function decodeBytes(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(decodeBytes);
+    }
+    else if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const key in obj) {
+            const val = obj[key];
+            if (val instanceof Uint8Array || ((val === null || val === void 0 ? void 0 : val.type) === 'Buffer' && Array.isArray(val.data))) {
+                const buffer = val instanceof Uint8Array ? val : Buffer.from(val.data);
+                result[key] = buffer.toString('hex');
+            }
+            else {
+                result[key] = decodeBytes(val);
+            }
+        }
+        return result;
+    }
+    else {
+        return obj;
+    }
+}
+client.GetObject(request, metadata, (err, response) => {
+    if (err) {
+        console.error('gRPC Error:', err);
+        console.error('Error details:', {
+            code: err.code,
+            details: err.details,
+            metadata: err.metadata
+        });
+        if (err.code === 14) {
+            console.error('Connection failed. Please check:');
+            console.error('1. QuickNode endpoint is correct');
+            console.error('2. Token is valid');
+            console.error('3. Network connection is stable');
+            console.error('4. Port 9000 is accessible');
+        }
+    }
+    else {
+        const decoded = decodeBytes(response);
+        console.log('Response:', JSON.stringify(decoded, null, 2));
+    }
+    client.close();
+});

package/dist/ttd-sui-common/src/test/test_checkpoint.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ttd-sui-common/src/test/test_checkpoint.js

@@ -0,0 +1,64 @@
+"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 });
+const dist_1 = require("@clonegod/ttd-core/dist");
+const fs_1 = require("fs");
+const grpc_connection_1 = require("../grpc/grpc-connection");
+const subscription_service_1 = require("../grpc/subscription-service");
+const grpc_endpoint = process.env.SUI_GRPC_ENDPOINT;
+const grpc_token = process.env.SUI_GRPC_TOKEN;
+const test_subscribe_checkpoints = () => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const subscriptionService = new subscription_service_1.SubscriptionService(connection);
+    const readMask = ['*'];
+    subscriptionService.subscribeCheckpoints((response) => {
+        const blockHash = response.checkpoint.digest;
+        const blockNumber = response.checkpoint.sequence_number;
+        const blockTime = response.checkpoint.summary.timestamp.seconds * 1000 + Math.floor(response.checkpoint.summary.timestamp.nanos / 1000000);
+        (0, dist_1.log_info)(blockNumber + ' - ' + response.checkpoint.transactions.length);
+        response.checkpoint.contents = {};
+        response.checkpoint.summary = {};
+        response.checkpoint.signature = {};
+        response.checkpoint.transactions.forEach((transaction) => {
+            transaction.signatures = [];
+            transaction.input_objects = [];
+            transaction.output_objects = [];
+        });
+        response.checkpoint.transactions = response.checkpoint.transactions.filter((transaction) => {
+            return transaction.transaction.kind.kind === 'programmable_transaction';
+        });
+        response.checkpoint.transactions = response.checkpoint.transactions.filter((transaction) => {
+            return transaction.events && transaction.events.events && transaction.events.events.length > 0;
+        });
+        let blockUpdateEvent = {
+            blockNumber,
+            blockHash,
+            blockTime,
+            transactions: []
+        };
+        response.checkpoint.transactions.forEach((transaction) => {
+            let event_types = transaction.events.events.map((event) => event.event_type) || [];
+        });
+        if (blockUpdateEvent.transactions.length > 0) {
+            (0, fs_1.writeFileSync)(`./dist/checkpoint_${response.cursor}_decoded.json`, JSON.stringify(response, null, 2));
+            console.dir(blockUpdateEvent, { depth: null });
+        }
+        else {
+            console.log(`no liquidity related events: ${response.cursor}, ${response.checkpoint.digest}`);
+        }
+    }, (error) => {
+        (0, dist_1.log_info)(`error`, error);
+    }, readMask);
+});
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    test_subscribe_checkpoints();
+});
+main();

package/dist/ttd-sui-common/src/test/test_grpc.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ttd-sui-common/src/test/test_grpc.js

@@ -0,0 +1,84 @@
+"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 });
+const dist_1 = require("@clonegod/ttd-core/dist");
+const grpc_connection_1 = require("../grpc/grpc-connection");
+const ledger_service_1 = require("../grpc/ledger-service");
+const live_data_service_1 = require("../grpc/live-data-service");
+const grpc_endpoint = process.env.SUI_GRPC_ENDPOINT;
+const grpc_token = process.env.SUI_GRPC_TOKEN;
+const test_get_service_info = () => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const ledgerService = new ledger_service_1.LedgerService(connection);
+    const serviceInfo = yield ledgerService.getServiceInfo();
+    (0, dist_1.log_info)(`serviceInfo`, serviceInfo);
+});
+const test_get_epoch = () => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const ledgerService = new ledger_service_1.LedgerService(connection);
+    const epoch = yield ledgerService.getEpoch();
+    (0, dist_1.log_info)(`epoch`, epoch);
+});
+const test_get_checkpoint = () => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const ledgerService = new ledger_service_1.LedgerService(connection);
+    const checkpoint = yield ledgerService.getCheckpoint();
+    (0, dist_1.log_info)(`checkpoint`, checkpoint);
+});
+const test_get_object = (object_id) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const ledgerService = new ledger_service_1.LedgerService(connection);
+    const object = yield ledgerService.getObject(object_id);
+    (0, dist_1.log_info)(`object`, object);
+});
+const test_get_objects = (object_ids) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const ledgerService = new ledger_service_1.LedgerService(connection);
+    const objects = yield ledgerService.batchGetObjects(object_ids);
+    (0, dist_1.log_info)(`objects`, objects);
+});
+const test_get_transaction = (txid) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const ledgerService = new ledger_service_1.LedgerService(connection);
+    const transaction = yield ledgerService.getTransaction(txid);
+    (0, dist_1.log_info)(`transaction`, transaction);
+});
+const test_get_balance = (wallet_address, coin_type) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const liveDataService = new live_data_service_1.LiveDataService(connection);
+    const balance = yield liveDataService.getBalance(wallet_address, coin_type);
+    (0, dist_1.log_info)(`balance`, balance);
+});
+const test_list_balances = (wallet_address) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const liveDataService = new live_data_service_1.LiveDataService(connection);
+    const balances = yield liveDataService.listBalances(wallet_address);
+    (0, dist_1.log_info)(`balances`, balances);
+});
+const test_get_coin_info = (coin_type) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const liveDataService = new live_data_service_1.LiveDataService(connection);
+    const coinInfo = yield liveDataService.getCoinInfo(coin_type);
+    (0, dist_1.log_info)(`coinInfo`, coinInfo);
+});
+const test_list_owned_objects = (wallet_address, coin_type) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
+    const liveDataService = new live_data_service_1.LiveDataService(connection);
+    const ownedObjects = yield liveDataService.listOwnedObjects(wallet_address, coin_type);
+    (0, dist_1.log_info)(`ownedObjects`, ownedObjects);
+});
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const wallet_address = '0x6367c8755b8c39cab7305bfa75cb17d050508d2e55f6862a7682377ad6d46ee7';
+    const usdc_coin_type = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';
+    const take_coin_type = '0x76a49ebaf991fa2d4cb6a352af14425d453fe2ba6802b5ed2361b227150b6689::take::TAKE';
+    test_list_owned_objects(wallet_address, take_coin_type);
+});
+main();

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