@clonegod/ttd-sui-common 1.0.101 → 2.0.1

package/dist/quote/verify/quote_price_verify.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotePriceVerify = void 0;
+const trade_direction_1 = require("../../utils/trade_direction");
+const ttd_core_1 = require("@clonegod/ttd-core");
+function pickMatchingTier(tiers, actualAmountIn) {
+    if (!tiers || tiers.length === 0)
+        return null;
+    if (tiers.length === 1)
+        return { tier: tiers[0], mode: 'single_tier', lo_pct: tiers[0].pct, hi_pct: tiers[0].pct };
+    const sorted = [...tiers].sort((a, b) => a.amount_in - b.amount_in);
+    const top = sorted[sorted.length - 1];
+    if (actualAmountIn < sorted[0].amount_in) {
+        return { tier: sorted[0], mode: 'extrapolated_low', lo_pct: null, hi_pct: sorted[0].pct };
+    }
+    if (actualAmountIn > top.amount_in) {
+        return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
+    }
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const lower = sorted[i];
+        const upper = sorted[i + 1];
+        if (actualAmountIn >= lower.amount_in && actualAmountIn <= upper.amount_in) {
+            if (actualAmountIn === lower.amount_in)
+                return { tier: lower, mode: 'exact', lo_pct: lower.pct, hi_pct: lower.pct };
+            if (actualAmountIn === upper.amount_in)
+                return { tier: upper, mode: 'exact', lo_pct: upper.pct, hi_pct: upper.pct };
+            const span = upper.amount_in - lower.amount_in;
+            if (span <= 0)
+                return { tier: lower, mode: 'exact', lo_pct: lower.pct, hi_pct: lower.pct };
+            const ratio = (actualAmountIn - lower.amount_in) / span;
+            const lerp = (a, b) => a + ratio * (b - a);
+            return {
+                tier: {
+                    pct: lerp(lower.pct, upper.pct),
+                    price: lerp(lower.price, upper.price),
+                    amount: lerp(lower.amount, upper.amount),
+                    amount_in: actualAmountIn,
+                    amount_in_usd: lerp(lower.amount_in_usd, upper.amount_in_usd),
+                    fee: lerp(lower.fee, upper.fee),
+                    fee_usd: lerp(lower.fee_usd, upper.fee_usd),
+                },
+                mode: 'interpolated',
+                lo_pct: lower.pct,
+                hi_pct: upper.pct,
+            };
+        }
+    }
+    return { tier: top, mode: 'extrapolated_high', lo_pct: top.pct, hi_pct: null };
+}
+class QuotePriceVerify {
+    constructor() {
+        this.quoteCache = new Map();
+    }
+    get enabled() {
+        return process.env.VERIFY_QUOTE_PRICE === 'true';
+    }
+    cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0, tiers) {
+        if (!this.enabled)
+            return;
+        if (!source)
+            return;
+        let sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap) {
+            sourceMap = new Map();
+            this.quoteCache.set(poolAddress, sourceMap);
+        }
+        const existing = sourceMap.get(source);
+        const verifiedReferenceBlock = (existing && existing.referenceBlock === blockNumber)
+            ? existing.verifiedReferenceBlock
+            : 0;
+        sourceMap.set(source, {
+            priceId, source, askPrice, bidPrice,
+            askTiers: tiers?.askTiers,
+            bidTiers: tiers?.bidTiers,
+            referenceBlock: blockNumber,
+            verifiedReferenceBlock,
+            quoteAmountUsd,
+            token0PriceUsd, token1PriceUsd,
+        });
+    }
+    checkSwap(params) {
+        if (!this.enabled)
+            return;
+        const { poolAddress, blockNumber, txHash, poolInfo, token0Address } = params;
+        const sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap || sourceMap.size === 0)
+            return;
+        const swapData = this.deriveSwapDirection(params);
+        if (!swapData)
+            return;
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const inputIsQuoteToken = swapData.inputTokenAddress.toLowerCase() === direction.quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const execPriceStr = (0, trade_direction_1.calculateStandardPrice)(swapData.inputAmountUi, swapData.outputAmountUi, isBuy);
+        const execPrice = Number(execPriceStr);
+        if (execPrice <= 0)
+            return;
+        const verifiable = [];
+        for (const [source, cached] of sourceMap) {
+            if (blockNumber <= cached.referenceBlock)
+                continue;
+            if (cached.verifiedReferenceBlock === cached.referenceBlock)
+                continue;
+            const tiers = isBuy ? cached.askTiers : cached.bidTiers;
+            let refPrice;
+            let tierInfo;
+            if (tiers && tiers.length > 0) {
+                const match = pickMatchingTier(tiers, swapData.inputAmountUi);
+                if (!match)
+                    continue;
+                refPrice = match.tier.price;
+                tierInfo = {
+                    matched_pct: parseFloat(match.tier.pct.toFixed(4)),
+                    mode: match.mode,
+                    tier_amount_in: match.tier.amount_in,
+                    lo_pct: match.lo_pct,
+                    hi_pct: match.hi_pct,
+                };
+            }
+            else {
+                refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+            }
+            if (refPrice <= 0)
+                continue;
+            cached.verifiedReferenceBlock = cached.referenceBlock;
+            const diff_bps = (refPrice - execPrice) / refPrice * 10000;
+            verifiable.push({ source, cached, refPrice, diff_bps, tierInfo });
+        }
+        if (verifiable.length === 0)
+            return;
+        verifiable.sort((a, b) => b.cached.referenceBlock - a.cached.referenceBlock);
+        const primary = verifiable[0];
+        const sources = {};
+        for (const r of verifiable) {
+            sources[r.source] = {
+                ask: r.cached.askPrice,
+                bid: r.cached.bidPrice,
+                matched_ref_price: r.refPrice,
+                diff_bps: parseFloat(r.diff_bps.toFixed(1)),
+                quote_block: r.cached.referenceBlock,
+                ...(r.tierInfo && {
+                    matched_pct: r.tierInfo.matched_pct,
+                    tier_mode: r.tierInfo.mode,
+                    tier_amount_in: r.tierInfo.tier_amount_in,
+                }),
+            };
+        }
+        return this.compareAndLog(poolAddress, params.poolName, poolInfo, primary.cached, swapData.inputTokenAddress, swapData.outputTokenAddress, swapData.inputAmountUi, swapData.outputAmountUi, primary.refPrice, execPrice, primary.cached.token0PriceUsd, primary.cached.token1PriceUsd, token0Address, blockNumber, txHash, sources, primary.tierInfo);
+    }
+    deriveSwapDirection(params) {
+        const { amount0, amount1, token0Address, token1Address, token0Decimals, token1Decimals } = params;
+        const sign = params.swapperDeltaConvention ? -1n : 1n;
+        const amt0 = BigInt(amount0) * sign;
+        const amt1 = BigInt(amount1) * sign;
+        if (amt0 === 0n && amt1 === 0n)
+            return null;
+        if (amt0 > 0n && amt1 < 0n) {
+            return {
+                inputTokenAddress: token0Address,
+                outputTokenAddress: token1Address,
+                inputAmountUi: Number(amt0) / Math.pow(10, token0Decimals),
+                outputAmountUi: Number(-amt1) / Math.pow(10, token1Decimals),
+            };
+        }
+        else if (amt0 < 0n && amt1 > 0n) {
+            return {
+                inputTokenAddress: token1Address,
+                outputTokenAddress: token0Address,
+                inputAmountUi: Number(amt1) / Math.pow(10, token1Decimals),
+                outputAmountUi: Number(-amt0) / Math.pow(10, token0Decimals),
+            };
+        }
+        return null;
+    }
+    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, refPrice, execPriceNum, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash, sources, primaryTierInfo) {
+        if (inputAmountUi <= 0 || outputAmountUi <= 0)
+            return;
+        let swapUsd = 0;
+        if (token0PriceUsd && token1PriceUsd && token0Address) {
+            const inputIsToken0 = inputTokenAddress.toLowerCase() === token0Address.toLowerCase();
+            swapUsd = inputIsToken0
+                ? inputAmountUi * token0PriceUsd
+                : inputAmountUi * token1PriceUsd;
+        }
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = direction.baseToken;
+        const quoteToken = direction.quoteToken;
+        const inputIsQuoteToken = inputTokenAddress.toLowerCase() === quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const side = isBuy ? 'BUY' : 'SELL';
+        if (refPrice <= 0 || execPriceNum <= 0)
+            return;
+        const diffBps = (refPrice - execPriceNum) / refPrice * 10000;
+        const absDiffBps = Math.abs(diffBps);
+        const status = absDiffBps < 5 ? '✅' : absDiffBps < 10 ? '⚠️' : '❌';
+        const usdStr = swapUsd > 0 ? `$${swapUsd.toFixed(0)}` : '$?';
+        const maxUsd = cached.quoteAmountUsd * 2;
+        const inRange = swapUsd <= 0 || swapUsd <= maxUsd;
+        const rangeTag = inRange ? '' : ' [out]';
+        const tradeFlow = isBuy
+            ? `${inputAmountUi.toFixed(4)} ${quoteToken.symbol} -> ${outputAmountUi.toFixed(4)} ${baseToken.symbol}`
+            : `${inputAmountUi.toFixed(4)} ${baseToken.symbol} -> ${outputAmountUi.toFixed(4)} ${quoteToken.symbol}`;
+        const quoteSrc = cached.source || '?';
+        const quoteTag = `quote[${quoteSrc} blk:${cached.referenceBlock}]`;
+        const swapBlk = swapBlockNumber || '?';
+        const swapTx = txHash ? ` ${txHash.slice(0, 10)}` : '';
+        const swapTag = `swap[blk:${swapBlk}${swapTx}]`;
+        const priceLabel = isBuy ? 'ask' : 'bid';
+        const msg = `  ↳ [Verify] ${side} ${usdStr} (${tradeFlow}) ${quoteTag} ${priceLabel}=${refPrice.toFixed(12)} vs ${swapTag} exec=${execPriceNum.toFixed(12)} diff=${diffBps > 0 ? '+' : ''}${diffBps.toFixed(1)}bps ${status}${rangeTag}`;
+        try {
+            (0, ttd_core_1.report_data_to_analyze)('QuoteVerify', {
+                pool_address: poolAddress,
+                pool_name: poolName,
+                price_id: cached.priceId,
+                source: cached.source,
+                quote_amount_usd: cached.quoteAmountUsd,
+                quote_block: cached.referenceBlock,
+                swap_block: swapBlockNumber,
+                tx_hash: txHash || '',
+                side,
+                ref_price: refPrice,
+                exec_price: execPriceNum,
+                diff_bps: parseFloat(diffBps.toFixed(1)),
+                swap_usd: parseFloat(swapUsd.toFixed(0)),
+                in_range: inRange,
+                input_amount: inputAmountUi,
+                output_amount: outputAmountUi,
+                input_symbol: isBuy ? quoteToken.symbol : baseToken.symbol,
+                output_symbol: isBuy ? baseToken.symbol : quoteToken.symbol,
+                status,
+                time: Date.now(),
+                sources: sources || undefined,
+                ...(primaryTierInfo && {
+                    matched_tier_pct: primaryTierInfo.matched_pct,
+                    matched_tier_mode: primaryTierInfo.mode,
+                    matched_tier_amount_in: primaryTierInfo.tier_amount_in,
+                    matched_tier_lo_pct: primaryTierInfo.lo_pct,
+                    matched_tier_hi_pct: primaryTierInfo.hi_pct,
+                }),
+            });
+        }
+        catch (_) {
+        }
+        return msg;
+    }
+}
+exports.QuotePriceVerify = QuotePriceVerify;

package/dist/redis/redis_client.d.ts

@@ -2,6 +2,7 @@ import { RedisClientType } from "redis";
 export declare class SimpleRedisClient {
     private lock_prefix;
     private redisClient;
+    private coreRedis;
     private lockMaxRetries;
     private lockRetryDelayMs;
     private lockExpireSeconds;

package/dist/redis/redis_client.js

@@ -1,13 +1,4 @@
 "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");
@@ -15,145 +6,125 @@ class SimpleRedisClient {
     constructor(lock_prefix) {
         this.lock_prefix = lock_prefix;
         this.redisClient = null;
+        this.coreRedis = (0, dist_1.getRedisClient)();
         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;
-        });
+    async getRedisClient() {
+        if (!this.redisClient) {
+            await this.coreRedis.init();
+            this.redisClient = this.coreRedis.redis_client;
+        }
+        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;
+    async acquireLock(lock_key, lock_value, expireSeconds = this.lockExpireSeconds) {
+        const redisClient = await this.getRedisClient();
+        const result = await 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 = `
+    async releaseLock(lock_key, lock_value) {
+        const redisClient = await 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;
+        const result = await 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 = 500) {
-            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 lock_start_time = Date.now();
-            let lock_acquired_time = 0;
-            try {
-                while (retries < this.lockMaxRetries) {
-                    acquired = yield this.acquireLock(lock_key, lock_value);
-                    if (acquired) {
-                        lock_acquired_time = Date.now();
-                        break;
-                    }
-                    yield new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
-                    (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}`);
-                    retries++;
-                }
+    async withLock(lock_identifier, callback, release_lock_delay_ms = 500) {
+        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 lock_start_time = Date.now();
+        let lock_acquired_time = 0;
+        try {
+            while (retries < this.lockMaxRetries) {
+                acquired = await this.acquireLock(lock_key, lock_value);
                 if (acquired) {
-                    return yield callback();
+                    lock_acquired_time = Date.now();
+                    break;
                 }
+                await new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
+                (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}`);
+                retries++;
             }
-            finally {
-                if (acquired) {
-                    const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
-                    if (release_delay > 0) {
-                        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}, retry_times=${retries}, release_lock_delay=${release_delay}ms, hold_lock=${Date.now() - lock_acquired_time}ms`);
-                }
-                else {
-                    (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, retry_times=${retries}, total_time=${Date.now() - lock_start_time}ms`);
+            if (acquired) {
+                return await callback();
+            }
+        }
+        finally {
+            if (acquired) {
+                const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
+                if (release_delay > 0) {
+                    await (0, dist_1.sleep)(release_delay);
                 }
+                await this.releaseLock(lock_key, lock_value);
+                (0, dist_1.log_info)(`withLock success: lock_key=${lock_key}, retry_times=${retries}, release_lock_delay=${release_delay}ms, hold_lock=${Date.now() - lock_acquired_time}ms`);
             }
-        });
+            else {
+                (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, retry_times=${retries}, total_time=${Date.now() - lock_start_time}ms`);
+            }
+        }
     }
-    getValue(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.get(key);
-        });
+    async getValue(key) {
+        const redisClient = await this.getRedisClient();
+        return await 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
-            });
+    async setValue(key, value, expireSeconds) {
+        const redisClient = await this.getRedisClient();
+        return await 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);
-        });
+    async hsetValue(key, field, value, expireSeconds) {
+        const redisClient = await this.getRedisClient();
+        await redisClient.hSet(key, field, value);
+        await 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);
-        });
+    async hgetvalue(key, field) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.hGet(key, field);
     }
-    hkeys(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.hKeys(key);
-        });
+    async hkeys(key) {
+        const redisClient = await this.getRedisClient();
+        return await redisClient.hKeys(key);
     }
-    hgetall(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const redisClient = yield this.getRedisClient();
-            return yield redisClient.hGetAll(key);
-        });
+    async hgetall(key) {
+        const redisClient = await this.getRedisClient();
+        return await 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);
-        });
+    async del(key, field = '') {
+        const redisClient = await this.getRedisClient();
+        if (field) {
+            return await redisClient.hDel(key, field);
+        }
+        return await redisClient.del(key);
     }
 }
 exports.SimpleRedisClient = SimpleRedisClient;

package/dist/rpc/index.js

@@ -1,85 +1,69 @@
 "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.get_all_objects_in_wallet = get_all_objects_in_wallet;
 exports.print_group_objects = print_group_objects;
-function get_all_objects_in_wallet(suiClient_1, walletAddress_1) {
-    return __awaiter(this, arguments, void 0, function* (suiClient, walletAddress, limit = 50) {
-        if (!walletAddress) {
-            throw new Error('walletAddress is required');
-        }
-        let allObjects = [];
-        let hasNextPage = true;
-        let cursor = null;
-        while (hasNextPage) {
-            const response = yield suiClient.getOwnedObjects({
-                owner: walletAddress,
-                limit: limit,
-                cursor: cursor,
-                options: {
-                    showType: true,
-                    showContent: true,
-                    showDisplay: true,
-                    showPreviousTransaction: true,
-                    showStorageRebate: true
-                }
-            });
-            allObjects = allObjects.concat(response.data);
-            hasNextPage = response.hasNextPage;
-            cursor = response.nextCursor || null;
-            console.log(`当前已查询到 ${allObjects.length} 个对象。 hasNextPage= ${hasNextPage}`);
-        }
-        return allObjects;
-    });
-}
-function print_group_objects(allObjects) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const objectTypeMap = new Map();
-        allObjects.forEach(obj => {
-            var _a;
-            const type = ((_a = obj.data) === null || _a === void 0 ? void 0 : _a.type) || 'unknown';
-            const count = objectTypeMap.get(type) || 0;
-            objectTypeMap.set(type, count + 1);
-        });
-        console.log(`\n=== 按类型分组的所有对象 ===`);
-        objectTypeMap.forEach((count, type) => {
-            console.log(`${type}: ${count} 个对象`);
-        });
-        console.log(`\n=== Coins ===`);
-        const typeGroups = new Map();
-        allObjects.forEach(obj => {
-            var _a;
-            const type = ((_a = obj.data) === null || _a === void 0 ? void 0 : _a.type) || 'unknown';
-            if (!typeGroups.has(type)) {
-                typeGroups.set(type, []);
+async function get_all_objects_in_wallet(suiClient, walletAddress, limit = 50) {
+    if (!walletAddress) {
+        throw new Error('walletAddress is required');
+    }
+    let allObjects = [];
+    let hasNextPage = true;
+    let cursor = null;
+    while (hasNextPage) {
+        const response = await suiClient.getOwnedObjects({
+            owner: walletAddress,
+            limit: limit,
+            cursor: cursor,
+            options: {
+                showType: true,
+                showContent: true,
+                showDisplay: true,
+                showPreviousTransaction: true,
+                showStorageRebate: true
             }
-            typeGroups.get(type).push(obj);
         });
-        let coinIndex = 1;
-        typeGroups.forEach((objects, type) => {
-            console.log(`\nCoin ${coinIndex} - ${type} (${objects.length} 个对象):`);
-            objects.forEach((obj, objIndex) => {
-                var _a, _b, _c, _d;
-                console.log(`  object ${objIndex + 1}:`);
-                console.log(`    - objectId: ${(_a = obj.data) === null || _a === void 0 ? void 0 : _a.objectId}`);
-                console.log(`    - version: ${(_b = obj.data) === null || _b === void 0 ? void 0 : _b.version}`);
-                console.log(`    - digest: ${(_c = obj.data) === null || _c === void 0 ? void 0 : _c.digest}`);
-                if (((_d = obj.data) === null || _d === void 0 ? void 0 : _d.content) && 'fields' in obj.data.content) {
-                    const fields = obj.data.content.fields;
-                    if (fields.balance) {
-                        console.log(`    - balance: ${fields.balance}`);
-                    }
+        allObjects = allObjects.concat(response.data);
+        hasNextPage = response.hasNextPage;
+        cursor = response.nextCursor || null;
+        console.log(`当前已查询到 ${allObjects.length} 个对象。 hasNextPage= ${hasNextPage}`);
+    }
+    return allObjects;
+}
+async function print_group_objects(allObjects) {
+    const objectTypeMap = new Map();
+    allObjects.forEach(obj => {
+        const type = obj.data?.type || 'unknown';
+        const count = objectTypeMap.get(type) || 0;
+        objectTypeMap.set(type, count + 1);
+    });
+    console.log(`\n=== 按类型分组的所有对象 ===`);
+    objectTypeMap.forEach((count, type) => {
+        console.log(`${type}: ${count} 个对象`);
+    });
+    console.log(`\n=== Coins ===`);
+    const typeGroups = new Map();
+    allObjects.forEach(obj => {
+        const type = obj.data?.type || 'unknown';
+        if (!typeGroups.has(type)) {
+            typeGroups.set(type, []);
+        }
+        typeGroups.get(type).push(obj);
+    });
+    let coinIndex = 1;
+    typeGroups.forEach((objects, type) => {
+        console.log(`\nCoin ${coinIndex} - ${type} (${objects.length} 个对象):`);
+        objects.forEach((obj, objIndex) => {
+            console.log(`  object ${objIndex + 1}:`);
+            console.log(`    - objectId: ${obj.data?.objectId}`);
+            console.log(`    - version: ${obj.data?.version}`);
+            console.log(`    - digest: ${obj.data?.digest}`);
+            if (obj.data?.content && 'fields' in obj.data.content) {
+                const fields = obj.data.content.fields;
+                if (fields.balance) {
+                    console.log(`    - balance: ${fields.balance}`);
                 }
-            });
-            coinIndex++;
+            }
         });
+        coinIndex++;
     });
 }

package/dist/test/test.js

@@ -88,7 +88,7 @@ function decodeBytes(obj) {
         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))) {
+            if (val instanceof Uint8Array || (val?.type === 'Buffer' && Array.isArray(val.data))) {
                 const buffer = val instanceof Uint8Array ? val : Buffer.from(val.data);
                 result[key] = buffer.toString('hex');
             }