wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,61 @@
+/**
+ * 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>;
+    get(key: string): Promise<string | undefined>;
+    getMany(keys: string[]): Promise<(string | undefined)[]>;
+    del(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface IAccountStorage {
+    get(): Promise<string | undefined>;
+    put(data: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class SQLiteStorage implements IStorage {
+    private _db;
+    private _dbSource;
+    constructor(db?: Database.Database);
+    private get db();
+    get(key: string): Promise<string | undefined>;
+    getMany(keys: string[]): Promise<(string | undefined)[]>;
+    put(key: string, value: string): Promise<void>;
+    putMany(items: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+    del(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class SQLiteAccountStorage implements IAccountStorage {
+    private _db;
+    private _dbSource;
+    constructor(db?: Database.Database);
+    private get db();
+    get(): Promise<string | undefined>;
+    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

@@ -0,0 +1,219 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var storage_exports = {};
+__export(storage_exports, {
+  SQLiteAccountStorage: () => SQLiteAccountStorage,
+  SQLiteStorage: () => SQLiteStorage,
+  defaultAccountStorage: () => defaultAccountStorage,
+  defaultStorage: () => defaultStorage,
+  resetAllDbConnections: () => resetAllDbConnections,
+  resetAllStorage: () => resetAllStorage
+});
+module.exports = __toCommonJS(storage_exports);
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_util = require("./util.js");
+const WOW_DIR = (0, import_util.getWowDir)();
+const CACHE_DB_PATH = path.join(WOW_DIR, "cache.db");
+const ACCOUNT_DB_PATH = path.join(WOW_DIR, "account.db");
+function ensureWowDirExists() {
+  if (!fs.existsSync(WOW_DIR)) {
+    fs.mkdirSync(WOW_DIR, { recursive: true });
+  }
+}
+ensureWowDirExists();
+function getCacheDatabase() {
+  ensureWowDirExists();
+  const db = new import_better_sqlite3.default(CACHE_DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS cache (
+			key TEXT PRIMARY KEY,
+			value TEXT NOT NULL,
+			updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+		);
+	`);
+  return db;
+}
+let cacheDbInstance = null;
+function getCacheDb() {
+  if (!cacheDbInstance) {
+    cacheDbInstance = getCacheDatabase();
+  }
+  return cacheDbInstance;
+}
+function getAccountDatabase() {
+  ensureWowDirExists();
+  const db = new import_better_sqlite3.default(ACCOUNT_DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  try {
+    fs.chmodSync(ACCOUNT_DB_PATH, 384);
+  } catch {
+  }
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS accounts (
+			id INTEGER PRIMARY KEY CHECK (id = 1),
+			data TEXT NOT NULL,
+			updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+		);
+	`);
+  return db;
+}
+let accountDbInstance = null;
+function getAccountDb() {
+  if (!accountDbInstance) {
+    accountDbInstance = getAccountDatabase();
+  }
+  return accountDbInstance;
+}
+class SQLiteStorage {
+  constructor(db) {
+    __publicField(this, "_db");
+    __publicField(this, "_dbSource");
+    this._dbSource = db;
+  }
+  get db() {
+    if (this._dbSource) {
+      return this._dbSource;
+    }
+    if (!this._db) {
+      this._db = getCacheDb();
+    }
+    return this._db;
+  }
+  async get(key) {
+    const row = this.db.prepare("SELECT value FROM cache WHERE key = ?").get(key);
+    return row?.value;
+  }
+  async getMany(keys) {
+    const placeholders = keys.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT key, value FROM cache WHERE key IN (${placeholders})`
+    ).all(...keys);
+    const map = new Map(rows.map((r) => [r.key, r.value]));
+    return keys.map((k) => map.get(k));
+  }
+  async put(key, value) {
+    this.db.prepare(
+      `
+			INSERT INTO cache (key, value, updated_at) 
+			VALUES (?, ?, strftime('%s', 'now'))
+			ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+		`
+    ).run(key, value);
+  }
+  async putMany(items) {
+    const stmt = this.db.prepare(`
+			INSERT INTO cache (key, value, updated_at) 
+			VALUES (?, ?, strftime('%s', 'now'))
+			ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+		`);
+    const insertMany = this.db.transaction(
+      (items2) => {
+        for (const item of items2) stmt.run(item.key, item.value);
+      }
+    );
+    insertMany(items);
+  }
+  async del(key) {
+    this.db.prepare("DELETE FROM cache WHERE key = ?").run(key);
+  }
+  async clear() {
+    this.db.exec("DELETE FROM cache");
+  }
+}
+class SQLiteAccountStorage {
+  constructor(db) {
+    __publicField(this, "_db");
+    __publicField(this, "_dbSource");
+    this._dbSource = db;
+  }
+  get db() {
+    if (this._dbSource) {
+      return this._dbSource;
+    }
+    if (!this._db) {
+      this._db = getAccountDb();
+    }
+    return this._db;
+  }
+  async get() {
+    const row = this.db.prepare("SELECT data FROM accounts WHERE id = 1").get();
+    return row?.data;
+  }
+  async put(data) {
+    this.db.prepare(
+      `
+			INSERT INTO accounts (id, data, updated_at) 
+			VALUES (1, ?, strftime('%s', 'now'))
+			ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+		`
+    ).run(data);
+  }
+  async clear() {
+    this.db.exec("DELETE FROM accounts");
+  }
+}
+function resetAllDbConnections() {
+  if (cacheDbInstance) {
+    try {
+      cacheDbInstance.close();
+    } catch (e) {
+    }
+    cacheDbInstance = null;
+  }
+  if (accountDbInstance) {
+    try {
+      accountDbInstance.close();
+    } catch (e) {
+    }
+    accountDbInstance = null;
+  }
+}
+process.on("exit", () => {
+  resetAllDbConnections();
+});
+process.on("SIGINT", () => {
+  resetAllDbConnections();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  resetAllDbConnections();
+  process.exit(0);
+});
+function resetAllStorage() {
+  resetAllDbConnections();
+}
+const defaultStorage = new SQLiteStorage();
+const defaultAccountStorage = new SQLiteAccountStorage();

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

@@ -0,0 +1,22 @@
+/**
+ * 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) */
+}
+export interface TokenDataFilter {
+    alias_or_name?: string;
+    symbol?: string;
+    type?: string;
+}
+export declare class TokenInfo {
+    static _instance: any;
+    static Instance(): TokenInfo;
+    private cacheKey;
+    private fetch_imp;
+    fetch(tokenType: string | null | undefined, alias?: string, network?: ENTRYPOINT): Promise<TokenTypeInfo | undefined>;
+    list(filter?: TokenDataFilter, network?: ENTRYPOINT): Promise<TokenTypeInfo[]>;
+}

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

@@ -0,0 +1,182 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var token_exports = {};
+__export(token_exports, {
+  TokenInfo: () => TokenInfo
+});
+module.exports = __toCommonJS(token_exports);
+var import_client = require("../../client/index.js");
+var import_network = require("../../client/network.js");
+var import_common = require("../common.js");
+var import_config = require("./config.js");
+var import_cache = require("./cache.js");
+var import_exception = require("../exception.js");
+const _TokenInfo = class _TokenInfo {
+  constructor() {
+    __publicField(this, "cacheKey", [import_cache.CachePrefix.token]);
+  }
+  static Instance() {
+    if (!_TokenInfo._instance) {
+      _TokenInfo._instance = new _TokenInfo();
+    }
+    return _TokenInfo._instance;
+  }
+  async fetch_imp(network, tokenType, alias) {
+    const client = new import_client.SuiClient({ url: (0, import_network.getFullnodeUrl)(network) });
+    const r = await client.getCoinMetadata({ coinType: tokenType });
+    if (r) {
+      return { alias, type: tokenType, ...r };
+    }
+    return void 0;
+  }
+  // alice - name - symbol - tokenType
+  async fetch(tokenType, alias, network) {
+    tokenType = tokenType ?? import_common.GasTokenType;
+    const net = await import_config.Config.Instance().network_get(network);
+    const cachedData = await import_cache.Cache.read(
+      [...this.cacheKey, net],
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: []
+        };
+      }
+    );
+    let foundToken = cachedData?.data?.find(
+      (token) => token.type === tokenType
+    );
+    if (!foundToken) {
+      foundToken = await this.fetch_imp(net, tokenType, alias);
+      if (!foundToken) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.TokenNotFoundLocally,
+          `token type: ${tokenType}`
+        );
+        return void 0;
+      }
+      const updatedTokens = [...cachedData?.data || [], foundToken];
+      await import_cache.Cache.read(
+        [...this.cacheKey, net],
+        async (_) => ({
+          expire: "INFINITE",
+          data: updatedTokens
+        }),
+        true
+        // 强制刷新缓存
+      );
+    } else if (alias && foundToken.alias !== alias) {
+      foundToken.alias = alias;
+      const updatedTokens = cachedData?.data?.map(
+        (token) => token.type === tokenType ? foundToken : token
+      ) || [];
+      await import_cache.Cache.read(
+        [...this.cacheKey, net],
+        async (_) => ({
+          expire: "INFINITE",
+          data: updatedTokens
+        }),
+        true
+        // 强制刷新缓存
+      );
+    }
+    return foundToken;
+  }
+  async list(filter, network) {
+    const net = await import_config.Config.Instance().network_get(network);
+    let cachedData = await import_cache.Cache.read(
+      [...this.cacheKey, net],
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: []
+        };
+      }
+    );
+    let tokens = cachedData?.data || [];
+    const targetType = filter?.type ?? import_common.GasTokenType;
+    const alias = filter?.type ? filter?.alias_or_name : void 0;
+    const foundByType = tokens.find((t) => t.type === targetType);
+    if (!foundByType) {
+      const fetched = await this.fetch_imp(net, targetType, alias);
+      if (fetched) {
+        const updatedTokens = [...tokens, fetched];
+        await import_cache.Cache.read(
+          [...this.cacheKey, net],
+          async (_) => ({
+            expire: "INFINITE",
+            data: updatedTokens
+          }),
+          true
+        );
+        cachedData = await import_cache.Cache.read(
+          [...this.cacheKey, net],
+          async (_) => ({
+            expire: "INFINITE",
+            data: updatedTokens
+          })
+        );
+        tokens = cachedData?.data || [];
+      }
+    }
+    if (filter) {
+      tokens = tokens.filter((token) => {
+        let match = true;
+        if (filter.symbol && match) {
+          match = token.symbol === filter.symbol;
+        }
+        if (filter.type && match) {
+          match = token.type === targetType;
+        }
+        return match;
+      });
+      if (filter.alias_or_name) {
+        const searchTerm = filter.alias_or_name.toLowerCase();
+        tokens = tokens.map((token) => {
+          let score = 0;
+          const alias2 = token.alias?.toLowerCase() || "";
+          const name = token.name?.toLowerCase() || "";
+          if (alias2 === searchTerm || name === searchTerm) {
+            score = 3;
+          } else if (alias2.startsWith(searchTerm) || name.startsWith(searchTerm)) {
+            score = 2;
+          } else if (alias2.includes(searchTerm) || name.includes(searchTerm)) {
+            score = 1;
+          }
+          return { ...token, _score: score };
+        });
+        tokens = tokens.filter((token) => token._score > 0).sort((a, b) => {
+          const scoreDiff = b._score - a._score;
+          if (scoreDiff !== 0) return scoreDiff;
+          const aNameLength = (a.alias?.length || 0) + (a.name?.length || 0);
+          const bNameLength = (b.alias?.length || 0) + (b.name?.length || 0);
+          return aNameLength - bNameLength;
+        });
+        tokens = tokens.map((token) => {
+          const { _score, ...rest } = token;
+          return rest;
+        });
+      }
+    }
+    return tokens;
+  }
+};
+__publicField(_TokenInfo, "_instance");
+let TokenInfo = _TokenInfo;

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

@@ -0,0 +1,5 @@
+/**
+ * 获取跨平台的 .wow 目录路径
+ * 支持通过 WOWOK_DATA_DIR 环境变量覆盖默认路径（主要用于测试隔离）
+ */
+export declare function getWowDir(): string;

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

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  getWowDir: () => getWowDir
+});
+module.exports = __toCommonJS(util_exports);
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+function getWowDir() {
+  if (process.env.WOWOK_DATA_DIR) {
+    return process.env.WOWOK_DATA_DIR;
+  }
+  const home = os.homedir();
+  const platform = os.platform();
+  if (platform === "win32") {
+    return path.join(home, ".wow");
+  } else if (platform === "darwin") {
+    return path.join(home, "Library", "Application Support", ".wow");
+  } else {
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    if (xdgConfig) {
+      return path.join(xdgConfig, ".wow");
+    }
+    const xdgData = process.env.XDG_DATA_HOME;
+    if (xdgData) {
+      return path.join(xdgData, ".wow");
+    }
+    return path.join(home, ".wow");
+  }
+}