wowok 2.1.38 → 2.1.40

package/dist/cjs/w/local/local.js

@@ -1,8 +1,3 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * manage address name and tags locally
- */
 import { isValidWowAddress } from "../../utils/sui-types.js";
 import { W_ERROR, WErrors } from "../exception.js";
 import { Cache, CachePrefix } from "./cache.js";
@@ -50,7 +45,6 @@ export class LocalMark {
         return name.slice(0, LocalMarkNameMaxLength);
     }
     async put(marks) {
-        // 获取现有所有标记
         const allMarksData = await Cache.read(this.cacheKey, async () => {
             return {
                 expire: "INFINITE",
@@ -58,13 +52,10 @@ export class LocalMark {
             };
         });
         const allMarks = allMarksData?.data || [];
-        const addedMarks = []; // 用于收集本次添加的标记
-        // 按数组顺序处理每个标记
+        const addedMarks = [];
         for (const mark of marks) {
-            // 地址统一转换为小写
             const addressLower = mark.address.toLowerCase();
             mark.address = addressLower;
-            // object address invalid
             if (!isValidAddress(mark.address)) {
                 W_ERROR(WErrors.IsValidAddress, `LocalMark.put.mark.address: ${mark.address}`);
             }
@@ -72,8 +63,6 @@ export class LocalMark {
                 mark.name.value = this.resolve_name(mark?.name?.value);
             }
             mark.tags = this.resolve_tags(mark?.tags);
-            // 检查并处理名称冲突
-            // 直接从allMarks中检查，包括之前添加的标记
             allMarks.forEach((m) => {
                 if (mark?.name?.value != null && m.name === mark?.name?.value) {
                     if (mark?.name?.replaceExistName) {
@@ -84,7 +73,6 @@ export class LocalMark {
                     }
                 }
             });
-            // 存储新标记
             const now = Date.now();
             const newMark = {
                 name: mark?.name?.value,
@@ -96,7 +84,6 @@ export class LocalMark {
             allMarks.push(newMark);
             addedMarks.push(newMark);
         }
-        // 更新所有标记缓存
         await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: allMarks,
@@ -113,12 +100,10 @@ export class LocalMark {
                 data: [],
             };
         });
-        // 检查缓存中是否已有匹配的token
         return cachedData?.data?.find((d) => d.name === name_or_address ||
             d.address.toLowerCase() === name_or_address.toLowerCase());
     }
     async get_address(name_or_address) {
-        // IMPORTANT: ADDRESS MAYBE NOT IN LOCAL MARK
         if (name_or_address && isValidAddress(name_or_address)) {
             return name_or_address.toLowerCase();
         }
@@ -135,55 +120,42 @@ export class LocalMark {
             };
         });
         const allMarks = cachedData?.data || [];
-        // 为每个输入的name_or_address查找匹配的标记
         return name_or_address.map((input) => {
             return allMarks.find((mark) => mark.name === input ||
                 mark.address.toLowerCase() === input?.toLowerCase());
         });
     }
     async get_many_address(name_or_address) {
-        // 创建结果数组，初始化为undefined
         const results = new Array(name_or_address.length).fill(undefined);
-        // 收集非地址输入及其在原始数组中的索引
         const nonAddressMap = new Map();
-        // 遍历原始数组，处理每个元素
         name_or_address.forEach((input, index) => {
             if (input === null || input === undefined) {
-                // 保持空值在原始位置
                 results[index] = undefined;
             }
             else if (isValidAddress(input)) {
-                // 保持有效地址在原始位置（统一转换为小写）
                 results[index] = input.toLowerCase();
             }
             else {
-                // 记录非地址输入及其索引
                 nonAddressMap.set(index, input);
             }
         });
-        // 提取非地址输入列表
         const nonAddressInputs = Array.from(nonAddressMap.values());
-        // 如果没有非地址输入，直接返回结果
         if (nonAddressInputs.length === 0) {
             return results;
         }
-        // 对非地址输入调用get_many获取对应的地址
         const nonAddressResults = await this.get_many(nonAddressInputs);
-        // 将查询结果放回原始数组中对应的位置
         let resultIndex = 0;
         nonAddressMap.forEach((input, originalIndex) => {
             const result = nonAddressResults[resultIndex];
             results[originalIndex] = result?.address;
             resultIndex++;
         });
-        // 返回完整的结果数组
         return results;
     }
     async get_many_address_availables(name_or_addresses) {
         return (await this.get_many_address(name_or_addresses)).filter((v) => v != null);
     }
     async del(name_or_address, delNotNamed = false) {
-        // 从所有标记缓存中删除
         const allMarksCacheKey = [
             CachePrefix.local_mark,
         ];
@@ -192,31 +164,21 @@ export class LocalMark {
             data: [],
         }));
         const allMarks = allMarksData?.data || [];
-        // 过滤标记
         const filteredMarks = allMarks.filter((mark) => {
-            // 检查是否匹配输入的名称或地址
-            // 只有当mark.name存在时才检查它是否在输入数组中
             const matchesName = mark.name !== undefined &&
                 mark.name !== null &&
                 name_or_address.includes(mark.name);
             const matchesAddress = name_or_address.includes(mark.address);
             const matchesInput = matchesName || matchesAddress;
-            // 检查名称是否为无效（undefined或null，但不包括空字符串）
             const isNameInvalid = mark.name === undefined || mark.name === null;
-            // 根据delNotNamed参数决定删除逻辑
             if (delNotNamed) {
-                // 如果为true，删除匹配输入的标记和名称无效的标记
-                // 保留不匹配输入且名称有效的标记
                 return !matchesInput && !isNameInvalid;
             }
             else {
-                // 如果为false，只删除匹配输入的标记
                 return !matchesInput;
             }
         });
-        // 计算被删除的标记
         const deletedMarks = allMarks.filter((mark) => !filteredMarks.includes(mark));
-        // 如果有标记被删除，更新缓存
         if (filteredMarks.length !== allMarks.length) {
             await Cache.read(allMarksCacheKey, async () => ({
                 expire: "INFINITE",
@@ -225,9 +187,7 @@ export class LocalMark {
         }
         return deletedMarks;
     }
-    // 使用Cache API重写clear方法
     async clear() {
-        // 获取所有标记
         const allMarksCacheKey = [
             CachePrefix.local_mark,
         ];
@@ -237,22 +197,18 @@ export class LocalMark {
         }), true);
         return true;
     }
-    // 使用Cache API重写rename方法
     async rename(name, new_name) {
         new_name = this.resolve_name(new_name);
         if (name === new_name) {
             return true;
         }
-        // 获取所有标记
         const allMarksData = await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: [],
         }));
         const allMarks = allMarksData?.data || [];
-        // 检查原名称是否存在且新名称不存在
         const old = allMarks.find((d) => d.name === name);
         if (old && allMarks.findIndex((d) => d.name === new_name) === -1) {
-            // 更新所有标记缓存
             const now = Date.now();
             old.name = new_name;
             old.updatedAt = now;
@@ -281,7 +237,6 @@ export class LocalMark {
             n1.updatedAt = now;
             n2.name = name1;
             n2.updatedAt = now;
-            // 更新所有标记缓存
             await Cache.read(this.cacheKey, async () => ({
                 expire: "INFINITE",
                 data: allMarks,
@@ -297,14 +252,11 @@ export class LocalMark {
             data: [],
         }));
         const allMarks = allMarksData?.data || [];
-        // 检查原名称是否存在
         const mark = allMarks.find((d) => d.name === name);
         if (mark) {
-            // 更新标记的标签
             const now = Date.now();
             mark.tags = tags;
             mark.updatedAt = now;
-            // 更新所有标记缓存
             await Cache.read(this.cacheKey, async () => ({
                 expire: "INFINITE",
                 data: allMarks,
@@ -313,23 +265,18 @@ export class LocalMark {
         }
         return false;
     }
-    // 使用Cache API重写list方法
     async list(filter) {
         if (filter && filter.tags)
             filter.tags = filter.tags.filter((v) => v !== "" && v);
-        // 获取所有标记
         const allMarksData = await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: [],
         }));
         const allMarks = allMarksData?.data || [];
-        // 转换为数组并应用过滤和排序
         return (allMarks
             .filter((mark) => {
-            // 地址精确匹配
             if (filter?.address && mark.address !== filter.address)
                 return false;
-            // 应用createdAt过滤
             if (filter?.createdAt) {
                 if (filter.createdAt.gte !== undefined &&
                     (!mark.createdAt ||
@@ -340,7 +287,6 @@ export class LocalMark {
                         mark.createdAt > filter.createdAt.lte))
                     return false;
             }
-            // 应用updatedAt过滤
             if (filter?.updatedAt) {
                 if (filter.updatedAt.gte !== undefined &&
                     (!mark.updatedAt ||
@@ -353,24 +299,21 @@ export class LocalMark {
             }
             return true;
         })
-            // 添加评分以便排序
             .map((mark) => {
             let score = 0;
             const lowerName = mark.name?.toLowerCase() || "";
             const lowerFilterName = filter?.name?.toLowerCase() || "";
-            // 名称匹配评分（参考token.ts的评分机制）
             if (filter?.name) {
                 if (lowerName === lowerFilterName) {
-                    score += 100; // 完全匹配最高优先级
+                    score += 100;
                 }
                 else if (lowerName.startsWith(lowerFilterName)) {
-                    score += 50; // 开头匹配次高优先级
+                    score += 50;
                 }
                 else if (lowerName.includes(lowerFilterName)) {
-                    score += 25; // 包含匹配较低优先级
+                    score += 25;
                 }
             }
-            // 标签匹配评分
             if (filter?.tags && filter.tags.length > 0) {
                 filter.tags.forEach((filterTag) => {
                     const lowerFilterTag = filterTag.toLowerCase();
@@ -378,41 +321,35 @@ export class LocalMark {
                         mark.tags.forEach((tag) => {
                             const lowerTag = tag.toLowerCase();
                             if (lowerTag === lowerFilterTag) {
-                                score += 20; // 标签完全匹配
+                                score += 20;
                             }
                             else if (lowerTag.startsWith(lowerFilterTag)) {
-                                score += 15; // 标签开头匹配
+                                score += 15;
                             }
                             else if (lowerTag.includes(lowerFilterTag)) {
-                                score += 10; // 标签包含匹配
+                                score += 10;
                             }
                         });
                     }
                 });
             }
-            // 如果有搜索条件但没有匹配项，将分数设为-1以过滤掉
             if ((filter?.name || filter?.tags) && score === 0) {
                 score = -1;
             }
             return { mark, score };
         })
-            // 过滤掉没有匹配项的结果
             .filter(({ score }) => score >= 0)
-            // 按分数降序排序，分数相同时按名称长度升序排序
             .sort((a, b) => {
             if (b.score !== a.score) {
                 return b.score - a.score;
             }
-            // 分数相同时按名称长度升序排序（参考token.ts的排序机制）
             const aNameLength = (a.mark.name || "").length;
             const bNameLength = (b.mark.name || "").length;
             if (aNameLength !== bNameLength) {
                 return aNameLength - bNameLength;
             }
-            // 名称长度相同时按字母顺序排序
             return (a.mark.name || "").localeCompare(b.mark.name || "");
         })
-            // 转换为所需的返回格式
             .map(({ mark }) => mark));
     }
 }
@@ -432,47 +369,37 @@ export class LocalInfo {
     resolve_name(name) {
         return name.slice(0, LocalInfoNameMaxLength);
     }
-    // 使用Cache API重写put方法
     async add(data) {
-        // 获取所有信息
         const allInfoData = await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: {},
         }));
         const allInfo = allInfoData?.data || {};
-        // 遍历传入的数据数组
         for (const item of data) {
-            // 处理名称
             const resolvedName = this.resolve_name(item.name);
-            // 处理内容
             const resolvedDefault = item.default.slice(0, LocalInfoContentMaxLength);
-            // 更新或创建信息
             if (allInfo[resolvedName]) {
-                // 更新现有信息
                 const now = Date.now();
                 const obj = allInfo[resolvedName];
                 obj.default = resolvedDefault;
-                // 只有当item.contents不为undefined时才更新contents
                 if (item.contents !== undefined) {
                     obj.contents = this.resolve_contents(item.contents);
                 }
                 obj.updatedAt = now;
             }
             else {
-                // 创建新信息
                 const now = Date.now();
                 const obj = {
                     default: resolvedDefault,
                     contents: item.contents
                         ? this.resolve_contents(item.contents)
-                        : [], // 新创建时如果contents为undefined则使用空数组
+                        : [],
                     createdAt: now,
                     updatedAt: now,
                 };
                 allInfo[resolvedName] = obj;
             }
         }
-        // 更新缓存
         await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: allInfo,
@@ -496,7 +423,6 @@ export class LocalInfo {
         if (!Array.isArray(names) || names.length === 0) {
             return [];
         }
-        // 只从缓存中读取一次所有信息
         const allInfoData = await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: {},
@@ -514,7 +440,6 @@ export class LocalInfo {
         }));
         const allInfo = allInfoData?.data || {};
         delete allInfo[name];
-        // 更新所有信息缓存
         await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: allInfo,
@@ -532,7 +457,6 @@ export class LocalInfo {
                 const now = Date.now();
                 info.contents = this.resolve_contents(contents);
                 info.updatedAt = now;
-                // 更新所有信息缓存
                 await Cache.read(this.cacheKey, async () => ({
                     expire: "INFINITE",
                     data: allInfo,
@@ -549,46 +473,41 @@ export class LocalInfo {
         }), true);
     }
     async list(filter) {
-        // 获取所有信息
         const allInfoData = await Cache.read(this.cacheKey, async () => ({
             expire: "INFINITE",
             data: {},
         }));
         const allInfo = allInfoData?.data || {};
-        // 转换为数组并应用过滤和排序
         return (Object.entries(allInfo)
             .map(([name, info]) => {
             let score = 0;
             const infoWithName = { name, ...info };
-            // 名称匹配评分（参考LocalMark.name的评分机制）
             if (filter?.name) {
                 const lowerName = name.toLowerCase();
                 const lowerFilterName = filter.name.toLowerCase();
                 if (lowerName === lowerFilterName) {
-                    score += 100; // 完全匹配最高优先级
+                    score += 100;
                 }
                 else if (lowerName.startsWith(lowerFilterName)) {
-                    score += 50; // 开头匹配次高优先级
+                    score += 50;
                 }
                 else if (lowerName.includes(lowerFilterName)) {
-                    score += 25; // 包含匹配较低优先级
+                    score += 25;
                 }
             }
-            // 默认内容匹配评分
             if (filter?.default) {
                 const lowerDefault = info.default.toLowerCase();
                 const lowerFilterDefault = filter.default.toLowerCase();
                 if (lowerDefault === lowerFilterDefault) {
-                    score += 90; // 完全匹配
+                    score += 90;
                 }
                 else if (lowerDefault.startsWith(lowerFilterDefault)) {
-                    score += 45; // 开头匹配
+                    score += 45;
                 }
                 else if (lowerDefault.includes(lowerFilterDefault)) {
-                    score += 22; // 包含匹配
+                    score += 22;
                 }
             }
-            // 内容列表匹配评分
             if (filter?.contents && filter.contents.length > 0) {
                 filter.contents.forEach((filterContent) => {
                     const lowerFilterContent = filterContent.toLowerCase();
@@ -596,30 +515,27 @@ export class LocalInfo {
                         info.contents.forEach((content) => {
                             const lowerContent = content.toLowerCase();
                             if (lowerContent === lowerFilterContent) {
-                                score += 20; // 完全匹配
+                                score += 20;
                             }
                             else if (lowerContent.startsWith(lowerFilterContent)) {
-                                score += 15; // 开头匹配
+                                score += 15;
                             }
                             else if (lowerContent.includes(lowerFilterContent)) {
-                                score += 10; // 包含匹配
+                                score += 10;
                             }
                         });
                     }
                 });
             }
-            // 如果有搜索条件但没有匹配项，将分数设为-1以过滤掉
             if ((filter?.name || filter?.default || filter?.contents) &&
                 score === 0) {
                 score = -1;
             }
             return { info: infoWithName, score };
         })
-            // 过滤掉没有匹配项的结果
             .filter(({ score, info }) => {
             if (score < 0)
                 return false;
-            // 应用createdAt过滤
             if (filter?.createdAt) {
                 if (filter.createdAt.gte !== undefined &&
                     (!info.createdAt ||
@@ -630,7 +546,6 @@ export class LocalInfo {
                         info.createdAt > filter.createdAt.lte))
                     return false;
             }
-            // 应用updatedAt过滤
             if (filter?.updatedAt) {
                 if (filter.updatedAt.gte !== undefined &&
                     (!info.updatedAt ||
@@ -643,22 +558,17 @@ export class LocalInfo {
             }
             return true;
         })
-            // 按分数降序排序，分数相同时按名称长度升序排序
             .sort((a, b) => {
             if (b.score !== a.score) {
                 return b.score - a.score;
             }
-            // 分数相同时按名称长度升序排序（参考LocalMark的排序机制）
             const aNameLength = a.info.name.length;
             const bNameLength = b.info.name.length;
             if (aNameLength !== bNameLength) {
                 return aNameLength - bNameLength;
             }
-            // 长度相同时按名称字母顺序升序排序
             return a.info.name.localeCompare(b.info.name);
         })
-            // 提取InfoData对象
             .map(({ info }) => info));
     }
 }
-//# sourceMappingURL=local.js.map

package/dist/cjs/w/local/storage.d.ts

@@ -1,15 +1,3 @@
-/**
- * SQLite 存储实现
- *
- * 架构：
- * - cache.db: 通用缓存数据
- * - account.db: 账户数据（更高安全级别）
- *
- * 特点：
- * 1. 进程安全 - 支持多进程并发访问
- * 2. 业务隔离 - cache 和 account 完全分离
- * 3. WAL 模式 - 高性能读写
- */
 import Database from "better-sqlite3";
 export interface IStorage {
     put(key: string, value: string): Promise<void>;
@@ -47,15 +35,7 @@ export declare class SQLiteAccountStorage implements IAccountStorage {
     put(data: string): Promise<void>;
     clear(): Promise<void>;
 }
-/**
- * 关闭并重置所有数据库连接
- * 用于测试时清理数据
- */
 export declare function resetAllDbConnections(): void;
-/**
- * 重置所有存储实例和数据库连接
- * 用于测试时完全清理数据
- */
 export declare function resetAllStorage(): void;
 export declare const defaultStorage: SQLiteStorage;
 export declare const defaultAccountStorage: SQLiteAccountStorage;

package/dist/cjs/w/local/storage.js

@@ -1,17 +1,3 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * SQLite 存储实现
- *
- * 架构：
- * - cache.db: 通用缓存数据
- * - account.db: 账户数据（更高安全级别）
- *
- * 特点：
- * 1. 进程安全 - 支持多进程并发访问
- * 2. 业务隔离 - cache 和 account 完全分离
- * 3. WAL 模式 - 高性能读写
- */
 import Database from "better-sqlite3";
 import * as path from "path";
 import * as fs from "fs";
@@ -25,7 +11,6 @@ function ensureWowDirExists() {
     }
 }
 ensureWowDirExists();
-// ========== Cache 数据库 ==========
 function getCacheDatabase() {
     ensureWowDirExists();
     const db = new Database(CACHE_DB_PATH);
@@ -47,18 +32,15 @@ function getCacheDb() {
     }
     return cacheDbInstance;
 }
-// ========== Account 数据库 ==========
 function getAccountDatabase() {
     ensureWowDirExists();
     const db = new Database(ACCOUNT_DB_PATH);
     db.pragma("journal_mode = WAL");
     db.pragma("synchronous = NORMAL");
-    // 设置更严格的文件权限（仅 Unix 系统有效）
     try {
         fs.chmodSync(ACCOUNT_DB_PATH, 0o600);
     }
     catch {
-        // Windows 或其他系统忽略权限设置错误
     }
     db.exec(`
 		CREATE TABLE IF NOT EXISTS accounts (
@@ -76,7 +58,6 @@ function getAccountDb() {
     }
     return accountDbInstance;
 }
-// ========== Cache 存储实现 ==========
 export class SQLiteStorage {
     _db;
     _dbSource;
@@ -134,7 +115,6 @@ export class SQLiteStorage {
         this.db.exec("DELETE FROM cache");
     }
 }
-// ========== Account 存储实现 ==========
 export class SQLiteAccountStorage {
     _db;
     _dbSource;
@@ -169,18 +149,12 @@ export class SQLiteAccountStorage {
         this.db.exec("DELETE FROM accounts");
     }
 }
-// ========== 数据库连接管理 ==========
-/**
- * 关闭并重置所有数据库连接
- * 用于测试时清理数据
- */
 export function resetAllDbConnections() {
     if (cacheDbInstance) {
         try {
             cacheDbInstance.close();
         }
         catch (e) {
-            // 忽略关闭错误
         }
         cacheDbInstance = null;
     }
@@ -189,34 +163,23 @@ export function resetAllDbConnections() {
             accountDbInstance.close();
         }
         catch (e) {
-            // 忽略关闭错误
         }
         accountDbInstance = null;
     }
 }
-// 注册进程退出时的清理函数
 process.on("exit", () => {
     resetAllDbConnections();
 });
-// 处理 SIGINT (Ctrl+C)
 process.on("SIGINT", () => {
     resetAllDbConnections();
     process.exit(0);
 });
-// 处理 SIGTERM
 process.on("SIGTERM", () => {
     resetAllDbConnections();
     process.exit(0);
 });
-/**
- * 重置所有存储实例和数据库连接
- * 用于测试时完全清理数据
- */
 export function resetAllStorage() {
-    // 先重置数据库连接
     resetAllDbConnections();
 }
-// ========== 默认实例 ==========
 export const defaultStorage = new SQLiteStorage();
 export const defaultAccountStorage = new SQLiteAccountStorage();
-//# sourceMappingURL=storage.js.map

package/dist/cjs/w/local/token.d.ts

@@ -1,11 +1,8 @@
-/**
- * coin type cache
- */
 import type { ENTRYPOINT } from "../../client/network.js";
 import type { CoinMetadata } from "../../client/index.js";
 export interface TokenTypeInfo extends CoinMetadata {
     alias?: string;
-    type: string; /** type name for the token (e.g., 0x168da5bf1f48dafc111b0a488fa454aca95e0b5e::usdc::USDC) */
+    type: string;
 }
 export interface TokenDataFilter {
     alias_or_name?: string;