@clonegod/ttd-sui-common 1.0.68 → 1.0.70

package/dist/ttd-sui-market-data/src/sui_objects/object_mgt.js

@@ -1,483 +0,0 @@
-"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.SuiWalletObjectsManagement = void 0;
-const dist_1 = require("@clonegod/ttd-core/dist");
-const grpc_1 = require("../../../ttd-sui-common/src/grpc");
-const redis_1 = require("../../../ttd-sui-common/src/redis");
-const config_manager_1 = require("./config_manager");
-const types_1 = require("./types");
-const version_checker_1 = require("./version_checker");
-class SuiWalletObjectsManagement {
-    constructor(appConfig, group_id, wallet_address) {
-        this.token_list = [];
-        this.appConfig = appConfig;
-        this.group_id = group_id;
-        this.wallet_address = wallet_address;
-        this.grpcClient = new grpc_1.SuiGrpcClient();
-        this.redisClient = new redis_1.SimpleRedisClient(wallet_address);
-        this.configManager = new config_manager_1.ConfigManager();
-        this.versionChecker = new version_checker_1.ObjectVersionChecker(this.redisClient, this.grpcClient, wallet_address);
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`🏗️ 初始化钱包对象管理系统: ${this.wallet_address}`);
-            yield this.init_trade_tokens();
-            yield this.initializeAllObjectPools();
-            this.versionChecker.start();
-            console.log(`✅ 钱包对象管理系统初始化完成`);
-        });
-    }
-    init_trade_tokens() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let token_list = [];
-            const trade_pools = yield this.appConfig.arb_cache.get_all_trade_pools(this.group_id);
-            for (const pool of trade_pools) {
-                let tokenAExist = token_list.some(token => token.address === pool.tokenA.address);
-                let tokenBExist = token_list.some(token => token.address === pool.tokenB.address);
-                if (!tokenAExist && pool.tokenA) {
-                    token_list.push(pool.tokenA);
-                }
-                if (!tokenBExist && pool.tokenB) {
-                    token_list.push(pool.tokenB);
-                }
-            }
-            this.token_list = token_list;
-            (0, dist_1.log_info)(`load_trade_pools token_list:`, {
-                group_id: this.group_id,
-                wallet_address: this.wallet_address,
-                token_list: token_list.map(token => token.address),
-            });
-        });
-    }
-    queryTokenObjectsFromChain(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                console.log(`🔍 从链上查询代币对象: ${tokenAddress}`);
-                const response = yield this.grpcClient.liveDataService.listOwnedObjects(this.wallet_address, tokenAddress, 100);
-                const objects = [];
-                if (response && response.objects) {
-                    for (const obj of response.objects) {
-                        const objectData = obj.object;
-                        if (objectData && objectData.balance) {
-                            objects.push({
-                                object_id: objectData.object_id,
-                                balance: BigInt(objectData.balance),
-                                version: objectData.version,
-                                status: types_1.ObjectStatus.AVAILABLE,
-                                allocated_at: undefined,
-                                allocated_by: undefined
-                            });
-                        }
-                    }
-                }
-                console.log(`✅ 从链上查询到 ${objects.length} 个 ${tokenAddress} 对象`);
-                return objects;
-            }
-            catch (error) {
-                console.error(`❌ 查询链上对象失败: ${tokenAddress}`, error);
-                return [];
-            }
-        });
-    }
-    initializeAllObjectPools() {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`🏗️ 初始化所有对象池`);
-            for (const token of this.token_list) {
-                yield this.initializeObjectPool(token.address);
-            }
-        });
-    }
-    initializeObjectPool(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`🏗️ 初始化代币对象池: ${tokenAddress}`);
-            const chainObjects = yield this.queryTokenObjectsFromChain(tokenAddress);
-            const config = this.configManager.getTokenConfig(tokenAddress);
-            const currentCount = chainObjects.length;
-            const needsMoreObjects = currentCount < config.min_objects;
-            if (needsMoreObjects) {
-                console.log(`⚠️ 对象数量不足: ${currentCount}/${config.min_objects}`);
-                yield this.performMaintenance(tokenAddress, 'split');
-            }
-            yield this.storeObjectsToRedis(tokenAddress, chainObjects);
-            console.log(`✅ 代币对象池初始化完成: ${tokenAddress}`);
-        });
-    }
-    allocateObjectForTrade(tokenAddress, requiredAmount, transactionHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(` 分配对象: ${tokenAddress}, 需要: ${requiredAmount}`);
-            const availableObjects = yield this.getAvailableObjects(tokenAddress);
-            availableObjects.sort((a, b) => Number(b.balance - a.balance));
-            for (const obj of availableObjects) {
-                if (BigInt(obj.balance) >= requiredAmount) {
-                    const allocated = yield this.allocateObject(tokenAddress, obj, transactionHash);
-                    if (allocated) {
-                        console.log(`✅ 对象分配成功: ${obj.object_id}, 余额: ${obj.balance}`);
-                        return allocated;
-                    }
-                }
-            }
-            console.log(`❌ 对象分配失败: 没有满足条件的对象 (需要: ${requiredAmount})`);
-            return null;
-        });
-    }
-    performMaintenance(tokenAddress, type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const availableObjects = yield this.getAvailableObjects(tokenAddress);
-            const config = this.configManager.getTokenConfig(tokenAddress);
-            if (type === 'auto' || !type) {
-                const maintenance = this.configManager.needsMaintenance(tokenAddress, availableObjects.length);
-                if (maintenance.needsSplit) {
-                    console.log(`   ⚠️ 需要拆分: ${maintenance.reason}`);
-                    yield this.performMaintenance(tokenAddress, 'split');
-                }
-                if (maintenance.needsMerge) {
-                    console.log(`   ⚠️ 需要合并: ${maintenance.reason}`);
-                    yield this.performMaintenance(tokenAddress, 'merge');
-                }
-                return;
-            }
-            if (type === 'split') {
-                console.log(`🔪 开始拆分维护: ${tokenAddress}`);
-                const largeObjects = availableObjects.filter(obj => BigInt(obj.balance) > BigInt(config.split_threshold));
-                if (largeObjects.length === 0) {
-                    console.log(`   ℹ️ 没有需要拆分的大对象`);
-                    return;
-                }
-                for (const obj of largeObjects) {
-                    yield this.splitObject(tokenAddress, obj);
-                }
-                console.log(`✅ 拆分维护完成: ${tokenAddress}`);
-            }
-            if (type === 'merge') {
-                console.log(`🔗 开始合并维护: ${tokenAddress}`);
-                const smallObjects = availableObjects.filter(obj => BigInt(obj.balance) < BigInt(config.merge_threshold));
-                if (smallObjects.length < 2) {
-                    console.log(`   ℹ️ 没有足够的小对象进行合并`);
-                    return;
-                }
-                yield this.mergeObjects(tokenAddress, smallObjects);
-                console.log(`✅ 合并维护完成: ${tokenAddress}`);
-            }
-        });
-    }
-    printPoolStatus(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stats = yield this.getPoolStats(tokenAddress);
-            const objects = yield this.getObjectsFromRedis(tokenAddress);
-            if (!stats) {
-                console.log(`❌ 对象池未初始化: ${tokenAddress}`);
-                return;
-            }
-            const config = this.configManager.getTokenConfig(tokenAddress);
-            console.log(`\n🏊 对象池状态: ${config.symbol} (${tokenAddress.slice(0, 8)}...)`);
-            console.log(`   配置: ${config.min_objects}-${config.max_objects} 对象 (目标: ${config.target_objects})`);
-            console.log(`   总对象数: ${stats.total_objects}`);
-            console.log(`   可用对象: ${stats.available_objects}`);
-            console.log(`   使用中对象: ${stats.allocated_objects}`);
-            console.log(`   维护中对象: ${stats.maintenance_objects}`);
-            console.log(`   最后更新: ${new Date(stats.last_updated).toLocaleString()}`);
-            console.log(`\n   对象详情:`);
-            for (const obj of objects.slice(0, 10)) {
-                const status = obj.status === types_1.ObjectStatus.AVAILABLE ? '🟢' :
-                    obj.status === types_1.ObjectStatus.ALLOCATED ? '🔒' : '🔧';
-                const allocatedInfo = obj.allocated_by ? ` (交易: ${obj.allocated_by.slice(0, 8)}...)` : '';
-                console.log(`     ${status} ${obj.object_id.slice(0, 8)}... - ${obj.balance.toString()} (v${obj.version})${allocatedInfo}`);
-            }
-            if (objects.length > 10) {
-                console.log(`     ... 还有 ${objects.length - 10} 个对象`);
-            }
-            console.log('');
-        });
-    }
-    allocateObject(tokenAddress, obj, transactionHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                status: types_1.ObjectStatus.ALLOCATED,
-                allocated_at: Date.now(),
-                allocated_by: transactionHash
-            });
-            return Object.assign(Object.assign({}, obj), { status: types_1.ObjectStatus.ALLOCATED, allocated_at: Date.now(), allocated_by: transactionHash });
-        });
-    }
-    releaseObject(tokenAddress, objectId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateObjectStatus(tokenAddress, objectId, {
-                status: types_1.ObjectStatus.AVAILABLE,
-                allocated_at: undefined,
-                allocated_by: undefined
-            });
-            console.log(` 释放对象: ${objectId}`);
-        });
-    }
-    poolOperation(tokenAddress, operation, objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const poolKey = `pool:${this.wallet_address}:${tokenAddress}:objects`;
-            switch (operation) {
-                case 'store':
-                    if (!objects)
-                        return;
-                    yield this.redisClient.hsetValue(poolKey, 'data', JSON.stringify(objects), 0);
-                    const stats = {
-                        total_objects: objects.length,
-                        available_objects: objects.filter(obj => obj.status === types_1.ObjectStatus.AVAILABLE).length,
-                        allocated_objects: objects.filter(obj => obj.status === types_1.ObjectStatus.ALLOCATED).length,
-                        maintenance_objects: objects.filter(obj => obj.status === types_1.ObjectStatus.MAINTENANCE).length,
-                        last_updated: Date.now()
-                    };
-                    yield this.redisClient.hsetValue(poolKey, 'stats', JSON.stringify(stats), 0);
-                    break;
-                case 'get':
-                    const objectsData = yield this.redisClient.hgetvalue(poolKey, 'data');
-                    return objectsData ? JSON.parse(objectsData) : [];
-                case 'getAvailable':
-                    const allObjects = yield this.poolOperation(tokenAddress, 'get');
-                    return allObjects.filter(obj => obj.status === types_1.ObjectStatus.AVAILABLE);
-            }
-        });
-    }
-    storeObjectsToRedis(tokenAddress, objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.poolOperation(tokenAddress, 'store', objects);
-        });
-    }
-    getObjectsFromRedis(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.poolOperation(tokenAddress, 'get');
-        });
-    }
-    getAvailableObjects(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.poolOperation(tokenAddress, 'getAvailable');
-        });
-    }
-    updateObjectStatus(tokenAddress, objectId, updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const poolKey = `pool:${this.wallet_address}:${tokenAddress}:objects`;
-            const objectsData = yield this.redisClient.hgetvalue(poolKey, 'data');
-            if (!objectsData)
-                return;
-            const objects = JSON.parse(objectsData);
-            const objectIndex = objects.findIndex(obj => obj.object_id === objectId);
-            if (objectIndex !== -1) {
-                objects[objectIndex] = Object.assign(Object.assign({}, objects[objectIndex]), updates);
-                yield this.redisClient.hsetValue(poolKey, 'data', JSON.stringify(objects), 0);
-                yield this.updatePoolStats(tokenAddress, objects);
-            }
-        });
-    }
-    updatePoolStats(tokenAddress, objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const poolKey = `pool:${this.wallet_address}:${tokenAddress}:objects`;
-            const stats = {
-                total_objects: objects.length,
-                available_objects: objects.filter(obj => obj.status === types_1.ObjectStatus.AVAILABLE).length,
-                allocated_objects: objects.filter(obj => obj.status === types_1.ObjectStatus.ALLOCATED).length,
-                maintenance_objects: objects.filter(obj => obj.status === types_1.ObjectStatus.MAINTENANCE).length,
-                last_updated: Date.now()
-            };
-            yield this.redisClient.hsetValue(poolKey, 'stats', JSON.stringify(stats), 0);
-        });
-    }
-    getPoolStats(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const poolKey = `pool:${this.wallet_address}:${tokenAddress}:objects`;
-            const statsData = yield this.redisClient.hgetvalue(poolKey, 'stats');
-            if (!statsData)
-                return null;
-            return JSON.parse(statsData);
-        });
-    }
-    splitObject(tokenAddress, obj) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`   🔪 拆分对象: ${obj.object_id} (余额: ${obj.balance})`);
-            yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                status: types_1.ObjectStatus.MAINTENANCE
-            });
-            try {
-                const splitResult = yield this.executeSplitTransaction(obj);
-                if (splitResult.success) {
-                    yield this.removeObjectFromPool(tokenAddress, obj.object_id);
-                    for (const newObject of splitResult.newObjects) {
-                        yield this.addObjectToPool(tokenAddress, {
-                            object_id: newObject.object_id,
-                            balance: BigInt(newObject.balance),
-                            version: newObject.version,
-                            status: types_1.ObjectStatus.AVAILABLE
-                        });
-                    }
-                    console.log(`   ✅ 拆分成功: ${obj.object_id} -> ${splitResult.newObjects.length} 个新对象`);
-                }
-                else {
-                    yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                        status: types_1.ObjectStatus.AVAILABLE
-                    });
-                    console.log(`   ❌ 拆分失败: ${obj.object_id}`);
-                }
-            }
-            catch (error) {
-                yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                    status: types_1.ObjectStatus.AVAILABLE
-                });
-                console.error(`   ❌ 拆分异常: ${obj.object_id}`, error);
-            }
-        });
-    }
-    mergeObjects(tokenAddress, objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`   🔗 合并对象: ${objects.length} 个`);
-            for (const obj of objects) {
-                yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                    status: types_1.ObjectStatus.MAINTENANCE
-                });
-            }
-            try {
-                const mergeResult = yield this.executeMergeTransaction(objects);
-                if (mergeResult.success) {
-                    for (const obj of objects) {
-                        yield this.removeObjectFromPool(tokenAddress, obj.object_id);
-                    }
-                    yield this.addObjectToPool(tokenAddress, {
-                        object_id: mergeResult.newObject.object_id,
-                        balance: BigInt(mergeResult.newObject.balance),
-                        version: mergeResult.newObject.version,
-                        status: types_1.ObjectStatus.AVAILABLE
-                    });
-                    console.log(`   ✅ 合并成功: ${objects.length} 个对象 -> 1 个新对象`);
-                }
-                else {
-                    for (const obj of objects) {
-                        yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                            status: types_1.ObjectStatus.AVAILABLE
-                        });
-                    }
-                    console.log(`   ❌ 合并失败`);
-                }
-            }
-            catch (error) {
-                for (const obj of objects) {
-                    yield this.updateObjectStatus(tokenAddress, obj.object_id, {
-                        status: types_1.ObjectStatus.AVAILABLE
-                    });
-                }
-                console.error(`   ❌ 合并异常`, error);
-            }
-        });
-    }
-    objectPoolOperation(tokenAddress, operation, objectId, obj) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const objects = yield this.getObjectsFromRedis(tokenAddress);
-            let updatedObjects;
-            switch (operation) {
-                case 'add':
-                    if (!obj)
-                        return;
-                    updatedObjects = [...objects, obj];
-                    break;
-                case 'remove':
-                    if (!objectId)
-                        return;
-                    updatedObjects = objects.filter(o => o.object_id !== objectId);
-                    break;
-                default:
-                    return;
-            }
-            yield this.storeObjectsToRedis(tokenAddress, updatedObjects);
-        });
-    }
-    removeObjectFromPool(tokenAddress, objectId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.objectPoolOperation(tokenAddress, 'remove', objectId);
-        });
-    }
-    addObjectToPool(tokenAddress, obj) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.objectPoolOperation(tokenAddress, 'add', undefined, obj);
-        });
-    }
-    executeSplitTransaction(obj) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`   🔄 执行拆分交易: ${obj.object_id}`);
-            return {
-                success: true,
-                newObjects: [
-                    {
-                        object_id: `${obj.object_id}_split_1`,
-                        balance: obj.balance / BigInt(2),
-                        version: obj.version + 1
-                    },
-                    {
-                        object_id: `${obj.object_id}_split_2`,
-                        balance: obj.balance / BigInt(2),
-                        version: obj.version + 1
-                    }
-                ]
-            };
-        });
-    }
-    executeMergeTransaction(objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`   🔄 执行合并交易: ${objects.length} 个对象`);
-            const totalBalance = objects.reduce((sum, obj) => sum + obj.balance, BigInt(0));
-            return {
-                success: true,
-                newObject: {
-                    object_id: `merged_${Date.now()}`,
-                    balance: totalBalance,
-                    version: Math.max(...objects.map(obj => obj.version)) + 1
-                }
-            };
-        });
-    }
-    grpcQuery(operation, coin_type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (operation) {
-                case 'listOwnedObjects':
-                    if (!coin_type)
-                        throw new Error('coin_type is required for listOwnedObjects');
-                    return yield this.grpcClient.liveDataService.listOwnedObjects(this.wallet_address, coin_type, 100, ['object_id', 'balance', 'object_type', 'version']);
-                case 'getBalance':
-                    if (!coin_type)
-                        throw new Error('coin_type is required for getBalance');
-                    return yield this.grpcClient.liveDataService.getBalance(this.wallet_address, coin_type);
-                case 'listBalances':
-                    return yield this.grpcClient.liveDataService.listBalances(this.wallet_address);
-                case 'getCoinInfo':
-                    if (!coin_type)
-                        throw new Error('coin_type is required for getCoinInfo');
-                    return yield this.grpcClient.liveDataService.getCoinInfo(coin_type);
-                default:
-                    throw new Error(`Unknown operation: ${operation}`);
-            }
-        });
-    }
-    listOwnedObjects(coin_type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.grpcQuery('listOwnedObjects', coin_type);
-        });
-    }
-    getBalance(coin_type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.grpcQuery('getBalance', coin_type);
-        });
-    }
-    listBalances() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.grpcQuery('listBalances');
-        });
-    }
-    getCoinInfo(coin_type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.grpcQuery('getCoinInfo', coin_type);
-        });
-    }
-}
-exports.SuiWalletObjectsManagement = SuiWalletObjectsManagement;

package/dist/ttd-sui-market-data/src/sui_objects/types.d.ts

@@ -1,60 +0,0 @@
-export declare enum ObjectStatus {
-    AVAILABLE = "available",
-    ALLOCATED = "allocated",
-    MAINTENANCE = "maintenance"
-}
-export interface ObjectInfo {
-    object_id: string;
-    balance: bigint;
-    version: number;
-    status: ObjectStatus;
-    allocated_at?: number;
-    allocated_by?: string;
-}
-export interface PoolStats {
-    total_objects: number;
-    available_objects: number;
-    allocated_objects: number;
-    maintenance_objects: number;
-    last_updated: number;
-}
-export interface TokenConfig {
-    address: string;
-    symbol: string;
-    min_objects: number;
-    max_objects: number;
-    target_objects: number;
-    min_balance_per_object: string;
-    max_balance_per_object: string;
-    split_threshold: string;
-    merge_threshold: string;
-    priority: number;
-    is_gas_token: boolean;
-}
-export declare enum MaintenanceType {
-    SPLIT = "split",
-    MERGE = "merge",
-    SYNC = "sync"
-}
-export interface MaintenanceTask {
-    type: MaintenanceType;
-    tokenAddress: string;
-    priority: number;
-    createdAt: number;
-}
-export declare enum ObjectEventType {
-    OBJECT_ALLOCATED = "OBJECT_ALLOCATED",
-    OBJECT_RELEASED = "OBJECT_RELEASED",
-    OBJECT_CREATED = "OBJECT_CREATED",
-    OBJECT_DELETED = "OBJECT_DELETED",
-    OBJECT_MAINTENANCE_START = "OBJECT_MAINTENANCE_START",
-    OBJECT_MAINTENANCE_END = "OBJECT_MAINTENANCE_END"
-}
-export interface ObjectEvent {
-    type: ObjectEventType;
-    objectId: string;
-    tokenAddress: string;
-    walletAddress: string;
-    timestamp: number;
-    data: any;
-}

package/dist/ttd-sui-market-data/src/sui_objects/types.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectEventType = exports.MaintenanceType = exports.ObjectStatus = void 0;
-var ObjectStatus;
-(function (ObjectStatus) {
-    ObjectStatus["AVAILABLE"] = "available";
-    ObjectStatus["ALLOCATED"] = "allocated";
-    ObjectStatus["MAINTENANCE"] = "maintenance";
-})(ObjectStatus || (exports.ObjectStatus = ObjectStatus = {}));
-var MaintenanceType;
-(function (MaintenanceType) {
-    MaintenanceType["SPLIT"] = "split";
-    MaintenanceType["MERGE"] = "merge";
-    MaintenanceType["SYNC"] = "sync";
-})(MaintenanceType || (exports.MaintenanceType = MaintenanceType = {}));
-var ObjectEventType;
-(function (ObjectEventType) {
-    ObjectEventType["OBJECT_ALLOCATED"] = "OBJECT_ALLOCATED";
-    ObjectEventType["OBJECT_RELEASED"] = "OBJECT_RELEASED";
-    ObjectEventType["OBJECT_CREATED"] = "OBJECT_CREATED";
-    ObjectEventType["OBJECT_DELETED"] = "OBJECT_DELETED";
-    ObjectEventType["OBJECT_MAINTENANCE_START"] = "OBJECT_MAINTENANCE_START";
-    ObjectEventType["OBJECT_MAINTENANCE_END"] = "OBJECT_MAINTENANCE_END";
-})(ObjectEventType || (exports.ObjectEventType = ObjectEventType = {}));

package/dist/ttd-sui-market-data/src/sui_objects/version_checker.d.ts

@@ -1,30 +0,0 @@
-import { SimpleRedisClient } from "../../../ttd-sui-common/src/redis";
-import { SuiGrpcClient } from "../../../ttd-sui-common/src/grpc";
-export declare class ObjectVersionChecker {
-    private redisClient;
-    private grpcClient;
-    private walletAddress;
-    private checkInterval;
-    private isRunning;
-    private checkTimer?;
-    private knownTokens;
-    constructor(redisClient: SimpleRedisClient, grpcClient: SuiGrpcClient, walletAddress: string, knownTokens?: string[]);
-    start(): void;
-    stop(): void;
-    private checkAllocatedObjects;
-    private checkObjectVersion;
-    private getAllocatedObjects;
-    private markObjectReleased;
-    private markObjectDeleted;
-    private updateObjectStatus;
-    private updatePoolStats;
-    private removeObjectFromPool;
-    private findObjectToken;
-    private publishObjectEvent;
-    updateKnownTokens(tokens: string[]): void;
-    getStatus(): {
-        isRunning: boolean;
-        checkInterval: number;
-        knownTokens: string[];
-    };
-}