wowok 2.1.38 → 2.1.40

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

@@ -44,9 +44,6 @@ export declare class Account {
     static _instance: any;
     static storage: IAccountStorage | undefined;
     setStorage(storage: IAccountStorage): void;
-    /**
-     * 获取存储实例，如果未初始化则自动初始化
-     */
     private getStorage;
     static Instance(): Account;
     private accountData;
@@ -76,59 +73,17 @@ export declare class Account {
     refund_coin(txb: Transaction, coin: CoinObject, to_address_or_name?: string): Promise<void>;
     transfer(amount: number | string | bigint, token_type?: string, to_address_or_name?: string, from_address_or_name?: string, network?: ENTRYPOINT): Promise<SuiTransactionBlockResponse | undefined>;
     coinObject_with_balance: (balance_required: string | bigint | number, token_type?: string, address_or_name?: string, network?: ENTRYPOINT) => Promise<string | undefined>;
-    /**
-     * 使用账户私钥对数据进行签名
-     *
-     * @param address_or_name 账户地址或名称
-     * @param data 要签名的数据（字符串或 Uint8Array）
-     * @returns 签名结果（hex 格式，带 0x 前缀）
-     */
     sign(address_or_name: string | null | undefined, data: string | Uint8Array): Promise<string>;
-    /**
-     * 使用账户私钥对数据进行签名（返回标准格式）
-     *
-     * @param address_or_name 账户地址或名称
-     * @param data 要签名的数据（字符串或 Uint8Array）
-     * @returns 签名结果对象，包含签名和公钥
-     */
     signData(address_or_name: string | null | undefined, data: string | Uint8Array): Promise<{
         signature: string;
         publicKey: string;
         address: string;
     }>;
-    /**
-     * 从账户的 ED25519 私钥确定性派生 X25519 密钥对 (XEd25519)
-     *
-     * 根据 XEd25519 规范，ED25519 私钥可以通过以下步骤转换为 X25519 私钥：
-     * 1. 对 ED25519 私钥进行 SHA-512 哈希
-     * 2. 取结果的前 32 字节
-     * 3. 按照 X25519 私钥格式进行位操作（清零 bit0, bit1, bit2, 设置 bit254, 清零 bit255）
-     *
-     * 这样可以从固定的 ED25519 私钥确定性派生出固定的 X25519 密钥对，
-     * 实现"恢复钱包即恢复加密身份"的功能。
-     *
-     * @param address_or_name 账户地址或名称
-     * @returns X25519 密钥对（私钥和公钥）
-     */
     deriveX25519KeyPair(address_or_name: string | null | undefined): Promise<{
         privateKey: Uint8Array;
         publicKey: Uint8Array;
     }>;
-    /**
-     * Set or unset messenger name for an account
-     * @param address_or_name Account address or name
-     * @param m Messenger name (null to remove)
-     * @returns Success status
-     */
     set_messenger(address_or_name: string | null | undefined, m: string | null): Promise<boolean>;
-    /**
-     * List all messenger enabled accounts
-     * @returns List of accounts with messenger enabled
-     */
     list_messenger_accounts(): Promise<AccountData[]>;
-    /**
-     * Count messenger enabled accounts
-     * @returns Number of messenger enabled accounts (excluding suspended)
-     */
     count_messenger_accounts(): Promise<number>;
 }

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

@@ -1,8 +1,3 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * account management
- */
 import { Ed25519Keypair } from "../../keypairs/ed25519/index.js";
 import { W_ERROR, WErrors } from "../exception.js";
 import { GasTokenType, isGasTokenType, isValidName, MAX_NAME_LENGTH, } from "../common.js";
@@ -21,9 +16,6 @@ export class Account {
     setStorage(storage) {
         Account.storage = storage;
     }
-    /**
-     * 获取存储实例，如果未初始化则自动初始化
-     */
     async getStorage() {
         if (!Account.storage) {
             Account.storage = new SQLiteAccountStorage();
@@ -65,14 +57,12 @@ export class Account {
             createdAt: now,
             updatedAt: now,
         };
-        // 【修复】先保存账户到本地存储
         const storage = await this.getStorage();
         const value = await storage.get();
         if (value) {
             const data = JSON.parse(value);
             const found = data.findIndex((d) => d.name === name);
             if (found !== -1) {
-                // found
                 if (replaceExistName) {
                     data[found].name = undefined;
                     data.push(ret);
@@ -89,8 +79,6 @@ export class Account {
         else {
             await storage.put(JSON.stringify([ret]));
         }
-        // 如果指定了 messenger 名称，保存到账号数据
-        // Messenger 的初始化由 MessengerManager 在首次使用时自动完成
         if (m) {
             const storage2 = await this.getStorage();
             const value2 = await storage2.get();
@@ -101,7 +89,6 @@ export class Account {
                     W_ERROR(WErrors.InvalidParam, `Maximum ${MAX_MESSENGER_ACCOUNTS} messenger accounts allowed, current count: ${messengerCount}`);
                 }
             }
-            // 保存 m 字段到账号数据
             ret.m = m;
             const storage3 = await this.getStorage();
             const value3 = await storage3.get();
@@ -120,7 +107,6 @@ export class Account {
     async default() {
         return this.accountData(await this.get_imp(DEFAULT_ACCOUNT_NAME));
     }
-    // address: if undefined, the default returned.
     async get(address_or_name, notFoundGenerate) {
         if (!notFoundGenerate) {
             return this.accountData(await this.get_imp(address_or_name));
@@ -203,24 +189,19 @@ export class Account {
         return true;
     }
     async rename(name_or_address, new_name) {
-        // Validate: new_name must be a valid name (not an address)
         if (new_name && !isValidName(new_name)) {
             W_ERROR(WErrors.IsValidName, `Invalid new name: "${new_name || ""}". Must be a valid name (not an address)`);
         }
-        // Resolve name_or_address (empty string -> default account name)
         const resolved_name = this.name_resolve(name_or_address);
-        // Check if renaming to the same name
         if (resolved_name === new_name)
             return true;
         const storage = await this.getStorage();
         const value = await storage.get();
         if (value) {
             const data = JSON.parse(value);
-            // Check: new_name must NOT exist
             if (data.find((d) => d.name === new_name)) {
                 W_ERROR(WErrors.IsValidName, `New name "${new_name || ""}" already exists`);
             }
-            // Check: name_or_address MUST exist (search by name or address)
             const f = data.find((d) => d.name === resolved_name ||
                 d.address.toLowerCase() === resolved_name.toLowerCase());
             if (!f) {
@@ -239,22 +220,18 @@ export class Account {
         const value = await storage.get();
         if (value) {
             let accounts = JSON.parse(value);
-            // 应用suspended过滤
             if (filter?.suspended !== undefined) {
                 accounts = accounts.filter((v) => filter.suspended ? v.suspended === true : !v.suspended);
             }
             else {
                 accounts = accounts.filter((v) => !v.suspended);
             }
-            // 应用hasMessenger过滤
             if (filter?.hasMessenger !== undefined) {
                 accounts = accounts.filter((v) => filter.hasMessenger ? v.m != null : v.m == null);
             }
-            // 应用m字段过滤（模糊搜索）
             if (filter?.m != null) {
                 accounts = accounts.filter((v) => v.m != null);
             }
-            // 应用createdAt过滤
             if (filter?.createdAt) {
                 if (filter.createdAt.gte !== undefined) {
                     accounts = accounts.filter((v) => v.createdAt &&
@@ -265,7 +242,6 @@ export class Account {
                         v.createdAt <= filter.createdAt.lte);
                 }
             }
-            // 应用updatedAt过滤
             if (filter?.updatedAt) {
                 if (filter.updatedAt.gte !== undefined) {
                     accounts = accounts.filter((v) => v.updatedAt &&
@@ -276,55 +252,49 @@ export class Account {
                         v.updatedAt <= filter.updatedAt.lte);
                 }
             }
-            // 应用name、address和m字段过滤（模糊搜索）
             if (filter?.name != null || filter?.address || filter?.m != null) {
-                // 添加评分以便排序
                 accounts = accounts
                     .map((account) => {
                     let score = 0;
-                    // 名称匹配评分
                     if (filter?.name != null) {
                         const lowerName = account.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?.address) {
                         const lowerAddress = account.address.toLowerCase();
                         const lowerFilterAddress = filter.address.toLowerCase();
                         if (lowerAddress === lowerFilterAddress) {
-                            score += 100; // 完全匹配最高优先级
+                            score += 100;
                         }
                         else if (lowerAddress.startsWith(lowerFilterAddress)) {
-                            score += 50; // 开头匹配次高优先级
+                            score += 50;
                         }
                         else if (lowerAddress.includes(lowerFilterAddress)) {
-                            score += 25; // 包含匹配较低优先级
+                            score += 25;
                         }
                     }
-                    // m字段匹配评分
                     if (filter?.m != null && account.m != null) {
                         const lowerM = account.m.toLowerCase();
                         const lowerFilterM = filter.m.toLowerCase();
                         if (lowerM === lowerFilterM) {
-                            score += 100; // 完全匹配最高优先级
+                            score += 100;
                         }
                         else if (lowerM.startsWith(lowerFilterM)) {
-                            score += 50; // 开头匹配次高优先级
+                            score += 50;
                         }
                         else if (lowerM.includes(lowerFilterM)) {
-                            score += 25; // 包含匹配较低优先级
+                            score += 25;
                         }
                     }
-                    // 如果有搜索条件但没有匹配项，将分数设为-1以过滤掉
                     if ((filter?.name ||
                         filter?.address ||
                         filter?.m != null) &&
@@ -333,11 +303,8 @@ export class Account {
                     }
                     return { account, score };
                 })
-                    // 过滤掉没有匹配项的结果
                     .filter(({ score }) => score >= 0)
-                    // 按分数降序排序
                     .sort((a, b) => b.score - a.score)
-                    // 提取账户数据
                     .map(({ account }) => account);
             }
             return accounts
@@ -432,7 +399,6 @@ export class Account {
                 return r.coins_sent || [];
             }
             catch (_e) {
-                //console.log(_e);
             }
         }
         return [];
@@ -454,7 +420,6 @@ export class Account {
         }
         return undefined;
     }
-    // token_type is the platform token, if not specified.
     balance = async (token_type, address_or_name, network) => {
         const a = await this.get(address_or_name);
         token_type = token_type ?? GasTokenType;
@@ -469,7 +434,6 @@ export class Account {
         }
         return undefined;
     };
-    // token_type is the platform token, if not specified.
     coin = async (token_type, cursor, limit, address_or_name, network) => {
         const a = await this.get(address_or_name);
         token_type = token_type ?? GasTokenType;
@@ -507,7 +471,6 @@ export class Account {
                     let current = BigInt(0);
                     for (let i = 0; i < r.data.length; ++i) {
                         const coinId = r.data[i].coinObjectId;
-                        // Skip duplicate coin objects
                         if (seen.has(coinId)) {
                             continue;
                         }
@@ -607,13 +570,6 @@ export class Account {
         }
         return undefined;
     };
-    /**
-     * 使用账户私钥对数据进行签名
-     *
-     * @param address_or_name 账户地址或名称
-     * @param data 要签名的数据（字符串或 Uint8Array）
-     * @returns 签名结果（hex 格式，带 0x 前缀）
-     */
     async sign(address_or_name, data) {
         const account = await this.get_imp(address_or_name);
         if (!account?.secret) {
@@ -624,13 +580,6 @@ export class Account {
         const signature = await pair.sign(dataBytes);
         return "0x" + Buffer.from(signature).toString("hex");
     }
-    /**
-     * 使用账户私钥对数据进行签名（返回标准格式）
-     *
-     * @param address_or_name 账户地址或名称
-     * @param data 要签名的数据（字符串或 Uint8Array）
-     * @returns 签名结果对象，包含签名和公钥
-     */
     async signData(address_or_name, data) {
         const account = await this.get_imp(address_or_name);
         if (!account?.secret) {
@@ -645,48 +594,22 @@ export class Account {
             address: account.address,
         };
     }
-    /**
-     * 从账户的 ED25519 私钥确定性派生 X25519 密钥对 (XEd25519)
-     *
-     * 根据 XEd25519 规范，ED25519 私钥可以通过以下步骤转换为 X25519 私钥：
-     * 1. 对 ED25519 私钥进行 SHA-512 哈希
-     * 2. 取结果的前 32 字节
-     * 3. 按照 X25519 私钥格式进行位操作（清零 bit0, bit1, bit2, 设置 bit254, 清零 bit255）
-     *
-     * 这样可以从固定的 ED25519 私钥确定性派生出固定的 X25519 密钥对，
-     * 实现"恢复钱包即恢复加密身份"的功能。
-     *
-     * @param address_or_name 账户地址或名称
-     * @returns X25519 密钥对（私钥和公钥）
-     */
     async deriveX25519KeyPair(address_or_name) {
         const account = await this.get_imp(address_or_name);
         if (!account?.secret) {
             W_ERROR(WErrors.InvalidParam, `Account not found or no secret key: ${address_or_name}`);
         }
-        // 获取 ED25519 私钥（64字节，包含公钥）
         const ed25519SecretKey = account.secret;
-        // 1. 对 ED25519 私钥进行 SHA-512 哈希
         const { sha512 } = await import("@noble/hashes/sha512");
         const hash = sha512(ed25519SecretKey);
-        // 2. 取前 32 字节作为 X25519 私钥种子
         const privateKey = new Uint8Array(hash.slice(0, 32));
-        // 3. 按照 X25519 私钥格式进行裁剪
-        // 参考: https://datatracker.ietf.org/doc/html/rfc7748#section-5
-        privateKey[0] &= 248; // 清零 bit0, bit1, bit2
-        privateKey[31] &= 127; // 清零 bit255
-        privateKey[31] |= 64; // 设置 bit254
-        // 4. 派生 X25519 公钥
+        privateKey[0] &= 248;
+        privateKey[31] &= 127;
+        privateKey[31] |= 64;
         const { x25519 } = await import("@noble/curves/ed25519");
         const publicKey = x25519.getPublicKey(privateKey);
         return { privateKey, publicKey };
     }
-    /**
-     * Set or unset messenger name for an account
-     * @param address_or_name Account address or name
-     * @param m Messenger name (null to remove)
-     * @returns Success status
-     */
     async set_messenger(address_or_name, m) {
         const resolved_address_or_name = this.name_resolve(address_or_name);
         const storage = await this.getStorage();
@@ -699,7 +622,6 @@ export class Account {
             v.name === resolved_address_or_name);
         if (!f)
             return false;
-        // 如果设置为 null，只是移除 messenger 名称，不需要注册
         if (!m) {
             const now = Date.now();
             f.m = undefined;
@@ -710,37 +632,25 @@ export class Account {
         if (!isValidName(m)) {
             W_ERROR(WErrors.IsValidName, `Messenger name ${m} is exceeds max ${MAX_NAME_LENGTH}`);
         }
-        // 【修复】只计算非 suspended 的 messenger 账户，与 list_messenger_accounts 保持一致
         const currentCount = data.filter((d) => d.m != null && !d.suspended && d.address !== f.address).length;
         if (currentCount >= MAX_MESSENGER_ACCOUNTS) {
             W_ERROR(WErrors.InvalidParam, `Maximum ${MAX_MESSENGER_ACCOUNTS} messenger accounts allowed, current count: ${currentCount}`);
         }
-        // 【修改】直接保存 m 字段，Messenger 的初始化由 MessengerManager 在首次使用时自动完成
         const now = Date.now();
         f.m = m;
         f.updatedAt = now;
         await storage.put(JSON.stringify(data));
         return true;
     }
-    /**
-     * List all messenger enabled accounts
-     * @returns List of accounts with messenger enabled
-     */
     async list_messenger_accounts() {
         return this.list({ hasMessenger: true });
     }
-    /**
-     * Count messenger enabled accounts
-     * @returns Number of messenger enabled accounts (excluding suspended)
-     */
     async count_messenger_accounts() {
         const storage = await this.getStorage();
         const value = await storage.get();
         if (!value)
             return 0;
         const data = JSON.parse(value);
-        // 【修复】排除 suspended 账户，与 list_messenger_accounts 保持一致
         return data.filter((d) => d.m != null && !d.suspended).length;
     }
 }
-//# sourceMappingURL=account.js.map

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

@@ -1,12 +1,4 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Cache is a class that provides a simple way to cache data.
- * It uses a Map to store the cached data in memory(default).
- * It also provides a way to store the cached data in a storage.
- */
 import { SQLiteStorage } from "./storage.js";
-// prefix + network + key
 export var CachePrefix;
 (function (CachePrefix) {
     CachePrefix["token"] = "token";
@@ -27,11 +19,9 @@ export class Cache {
     static hasStorage() {
         return Cache.storage !== undefined && Cache.storage !== null;
     }
-    // 初始化默认存储
     static initDefaultStorage() {
         Cache.storage = new SQLiteStorage();
     }
-    // 静态初始化
     static {
         Cache.initDefaultStorage();
     }
@@ -48,11 +38,9 @@ export class Cache {
         return Date.now() + 120000;
     };
     static async storeData(cacheKey, data) {
-        // Always store in both storage and memory if storage is available
         if (Cache.hasStorage()) {
             await Cache.storage.put(cacheKey, JSON.stringify(data));
         }
-        // Always update memory cache for fast access
         Cache.memory.set(cacheKey, data);
     }
     static async read(key, load, bForceLoad) {
@@ -74,9 +62,7 @@ export class Cache {
                 }
             }
         }
-        // Load fresh data
         const result = load(key);
-        // Handle both sync and async results
         if (typeof result === "object" && result !== null && "then" in result) {
             return result
                 .then(async (v) => {
@@ -86,7 +72,6 @@ export class Cache {
                 return v;
             })
                 .catch((err) => {
-                // If there's an error, we don't want to cache anything
                 throw err;
             });
         }
@@ -96,26 +81,22 @@ export class Cache {
         return result;
     }
     static async read_many(prefix, keys, load, bForceLoad) {
-        //console.log(`read many: ${prefix}, ${keys}, ${bForceLoad}`);
         if (!keys || keys.length === 0) {
             return [];
         }
         const results = new Array(keys.length);
         const pendingKeys = [];
         const pendingIndices = [];
-        // Check cache for each key
         for (let i = 0; i < keys.length; i++) {
             const cacheKey = `${prefix}:${keys[i]}`;
             let cachedData;
             if (!bForceLoad) {
-                // Check memory cache first
                 if (Cache.memory.has(cacheKey)) {
                     const cachedValue = Cache.memory.get(cacheKey);
                     if (Cache.notExpired(cachedValue)) {
                         cachedData = cachedValue;
                     }
                 }
-                // Check storage cache if not found in memory or expired
                 if (!cachedData && Cache.hasStorage()) {
                     try {
                         const cachedValue = await Cache.storage.get(cacheKey);
@@ -123,14 +104,11 @@ export class Cache {
                             const parsed = JSON.parse(cachedValue);
                             if (Cache.notExpired(parsed)) {
                                 cachedData = parsed;
-                                // Update memory cache for faster access next time
                                 Cache.memory.set(cacheKey, parsed);
                             }
                         }
                     }
                     catch (_) {
-                        // If cache read fails, treat as cache miss
-                        // console.error(`Cache read error for key ${cacheKey}:`, e);
                     }
                 }
             }
@@ -142,32 +120,25 @@ export class Cache {
                 pendingIndices.push(i);
             }
         }
-        // Load missing data if any
         if (pendingKeys.length > 0) {
             try {
                 const loadedData = await load(prefix, pendingKeys);
                 if (loadedData && loadedData.length > 0) {
-                    // Update cache and results array
                     for (let i = 0; i < loadedData.length; i++) {
                         const data = loadedData[i];
                         const cacheKey = `${prefix}:${pendingKeys[i]}`;
                         const resultIndex = pendingIndices[i];
                         if (data) {
-                            // Store in cache
                             await Cache.storeData(cacheKey, data);
                             Cache.memory.set(cacheKey, data);
-                            // Update results array
                             results[resultIndex] = data;
                         }
                     }
                 }
             }
             catch (e) {
-                // If load fails, we still return the cached data we have
-                // console.error('Cache load_many error:', e);
             }
         }
-        // Filter out undefined values if all results are undefined, return undefined
         return results.filter((item) => item !== undefined);
     }
     static async del(key) {
@@ -188,4 +159,3 @@ export class Cache {
         }
     }
 }
-//# sourceMappingURL=cache.js.map

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

@@ -1,6 +1,3 @@
-/**
- * config
- */
 import { ENTRYPOINT } from "../../client/network.js";
 export interface ConfigData {
     network: ENTRYPOINT;

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

@@ -1,8 +1,3 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * config
- */
 import { ENTRYPOINT } from "../../client/network.js";
 import { Cache, CachePrefix } from "./cache.js";
 export class Config {
@@ -14,7 +9,6 @@ export class Config {
         return Config._instance;
     }
     cacheKey = [CachePrefix.config];
-    // default 'testnet'
     async network_get(current) {
         if (current) {
             await this.network_set(current);
@@ -47,4 +41,3 @@ export class Config {
         return cachedData?.data;
     }
 }
-//# sourceMappingURL=config.js.map

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

@@ -1,8 +1,5 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
 import { GasTokenType } from "../common.js";
 import { W_ERROR, WErrors } from "../exception.js";
-// eslint-disable-next-line import/no-cycle
 import { Account } from "./account.js";
 import { LocalInfo, LocalInfoNameDefault, LocalMark } from "./local.js";
 import { TokenInfo } from "./token.js";
@@ -164,7 +161,6 @@ export const account_operation = async (op) => {
     if (op.signData != null) {
         const { name_or_address, data, data_encoding } = op.signData;
         let dataToSign = data;
-        // 如果 data 是字符串且指定了编码，转换为 Uint8Array
         if (typeof data === "string" && data_encoding) {
             switch (data_encoding) {
                 case "base64":
@@ -230,4 +226,3 @@ export * from "./config.js";
 export * from "./local.js";
 export * from "./token.js";
 export * from "./wip.js";
-//# sourceMappingURL=index.js.map