wowok 1.8.2 → 2.1.9

package/dist/esm/w/local/cache.d.ts

@@ -0,0 +1,35 @@
+export type CacheExpireType = number | "INFINITE";
+export interface CachedData<T = any> {
+    expire: CacheExpireType;
+    data: T;
+}
+export declare enum CachePrefix {
+    token = "token",
+    object = "object",
+    personal = "personal",
+    table = "table",
+    config = "config",
+    local_mark = "mark",
+    local_info = "info",
+    event = "event"
+}
+export interface IStorage {
+    put(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | undefined>;
+    del(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class Cache {
+    static storage: IStorage | null | undefined;
+    static memory: Map<string, CachedData<any>>;
+    static setStorage(storage?: IStorage | null | undefined): void;
+    static hasStorage(): boolean;
+    static initDefaultStorage(): void;
+    static notExpired<T>(cache: CachedData<T>): boolean;
+    static DefaultExpireTime: (bInfinite?: boolean) => CacheExpireType;
+    private static storeData;
+    static read<T = any>(key: [string, ...string[]], load: (key: [string, ...string[]]) => CachedData<T> | undefined | Promise<CachedData<T>> | Promise<undefined>, bForceLoad?: boolean): Promise<CachedData<T> | undefined>;
+    static read_many<T = any>(prefix: string, keys: string[], load: (prefix: string, load_keys: string[]) => Promise<CachedData<T>[]> | Promise<undefined>, bForceLoad?: boolean): Promise<CachedData<T>[]>;
+    static del(key: [string, ...string[]]): Promise<void>;
+    static clear(): void;
+}

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

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { SQLiteStorage } from "./storage.js";
+var CachePrefix = /* @__PURE__ */ ((CachePrefix2) => {
+  CachePrefix2["token"] = "token";
+  CachePrefix2["object"] = "object";
+  CachePrefix2["personal"] = "personal";
+  CachePrefix2["table"] = "table";
+  CachePrefix2["config"] = "config";
+  CachePrefix2["local_mark"] = "mark";
+  CachePrefix2["local_info"] = "info";
+  CachePrefix2["event"] = "event";
+  return CachePrefix2;
+})(CachePrefix || {});
+const _Cache = class _Cache {
+  static setStorage(storage) {
+    _Cache.storage = storage;
+  }
+  static hasStorage() {
+    return _Cache.storage !== void 0 && _Cache.storage !== null;
+  }
+  // 初始化默认存储
+  static initDefaultStorage() {
+    _Cache.storage = new SQLiteStorage();
+  }
+  static notExpired(cache) {
+    if (!cache?.expire) return false;
+    if (cache.expire === "INFINITE") return true;
+    return cache.expire > Date.now();
+  }
+  static async storeData(cacheKey, data) {
+    if (_Cache.hasStorage()) {
+      await _Cache.storage.put(cacheKey, JSON.stringify(data));
+    }
+    _Cache.memory.set(cacheKey, data);
+  }
+  static async read(key, load, bForceLoad) {
+    const cacheKey = key.join(":");
+    if (!bForceLoad) {
+      if (_Cache.memory.has(cacheKey)) {
+        const cachedValue = _Cache.memory.get(cacheKey);
+        if (_Cache.notExpired(cachedValue)) {
+          return cachedValue;
+        }
+      }
+      if (_Cache.hasStorage()) {
+        const cachedValue = await _Cache.storage.get(cacheKey);
+        if (cachedValue) {
+          const parsed = JSON.parse(cachedValue);
+          if (_Cache.notExpired(parsed)) {
+            return parsed;
+          }
+        }
+      }
+    }
+    const result = load(key);
+    if (typeof result === "object" && result !== null && "then" in result) {
+      return result.then(async (v) => {
+        if (!v) return void 0;
+        await _Cache.storeData(cacheKey, v);
+        return v;
+      }).catch((err) => {
+        throw err;
+      });
+    }
+    if (result) {
+      await _Cache.storeData(cacheKey, result);
+    }
+    return result;
+  }
+  static async read_many(prefix, keys, load, bForceLoad) {
+    if (!keys || keys.length === 0) {
+      return [];
+    }
+    const results = new Array(keys.length);
+    const pendingKeys = [];
+    const pendingIndices = [];
+    for (let i = 0; i < keys.length; i++) {
+      const cacheKey = `${prefix}:${keys[i]}`;
+      let cachedData;
+      if (!bForceLoad) {
+        if (_Cache.memory.has(cacheKey)) {
+          const cachedValue = _Cache.memory.get(cacheKey);
+          if (_Cache.notExpired(cachedValue)) {
+            cachedData = cachedValue;
+          }
+        }
+        if (!cachedData && _Cache.hasStorage()) {
+          try {
+            const cachedValue = await _Cache.storage.get(cacheKey);
+            if (cachedValue) {
+              const parsed = JSON.parse(
+                cachedValue
+              );
+              if (_Cache.notExpired(parsed)) {
+                cachedData = parsed;
+                _Cache.memory.set(
+                  cacheKey,
+                  parsed
+                );
+              }
+            }
+          } catch (_) {
+          }
+        }
+      }
+      if (cachedData) {
+        results[i] = cachedData;
+      } else {
+        pendingKeys.push(keys[i]);
+        pendingIndices.push(i);
+      }
+    }
+    if (pendingKeys.length > 0) {
+      try {
+        const loadedData = await load(prefix, pendingKeys);
+        if (loadedData && loadedData.length > 0) {
+          for (let i = 0; i < loadedData.length; i++) {
+            const data = loadedData[i];
+            const cacheKey = `${prefix}:${pendingKeys[i]}`;
+            const resultIndex = pendingIndices[i];
+            if (data) {
+              await _Cache.storeData(cacheKey, data);
+              _Cache.memory.set(cacheKey, data);
+              results[resultIndex] = data;
+            }
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return results.filter((item) => item !== void 0);
+  }
+  static async del(key) {
+    const cacheKey = key.join(":");
+    if (_Cache.hasStorage()) {
+      await _Cache.storage.del(cacheKey);
+    } else {
+      _Cache.memory.delete(cacheKey);
+    }
+  }
+  static clear() {
+    if (_Cache.hasStorage()) {
+      _Cache.storage.clear();
+    } else {
+      _Cache.memory.clear();
+    }
+  }
+};
+__publicField(_Cache, "storage");
+__publicField(_Cache, "memory", /* @__PURE__ */ new Map());
+_Cache.initDefaultStorage();
+__publicField(_Cache, "DefaultExpireTime", (bInfinite) => {
+  if (bInfinite) return "INFINITE";
+  return Date.now() + 12e4;
+});
+let Cache = _Cache;
+export {
+  Cache,
+  CachePrefix
+};

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

@@ -0,0 +1,15 @@
+/**
+ * config
+ */
+import { ENTRYPOINT } from "../../client/network.js";
+export interface ConfigData {
+    network: ENTRYPOINT;
+}
+export declare class Config {
+    static _instance: any;
+    static Instance(): Config;
+    private cacheKey;
+    network_get(current?: ENTRYPOINT): Promise<ENTRYPOINT>;
+    network_set(network: ENTRYPOINT): Promise<void>;
+    list(): Promise<ConfigData | undefined>;
+}

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

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { ENTRYPOINT } from "../../client/network.js";
+import { Cache, CachePrefix } from "./cache.js";
+const _Config = class _Config {
+  constructor() {
+    __publicField(this, "cacheKey", [CachePrefix.config]);
+  }
+  static Instance() {
+    if (!_Config._instance) {
+      _Config._instance = new _Config();
+    }
+    return _Config._instance;
+  }
+  // default 'testnet'
+  async network_get(current) {
+    if (current) {
+      await this.network_set(current);
+      return current;
+    }
+    const cachedData = await Cache.read(
+      this.cacheKey,
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: { network: ENTRYPOINT.Testnet }
+        };
+      }
+    );
+    return cachedData?.data?.network;
+  }
+  async network_set(network) {
+    const cacheKey = [CachePrefix.config];
+    await Cache.read(
+      cacheKey,
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: { network }
+        };
+      },
+      true
+      // 强制刷新缓存
+    );
+  }
+  async list() {
+    const cachedData = await Cache.read(
+      this.cacheKey,
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: { network: ENTRYPOINT.Testnet }
+        };
+      }
+    );
+    return cachedData?.data;
+  }
+};
+__publicField(_Config, "_instance");
+let Config = _Config;
+export {
+  Config
+};

package/dist/esm/w/local/index.d.ts

@@ -0,0 +1,193 @@
+import type { CoinBalance, PaginatedCoins, SuiTransactionBlockResponse } from "../../client/index.js";
+import type { ENTRYPOINT } from "../../client/network.js";
+import type { AccountData, AccountFilter, FaucetCoinInfo } from "./account.js";
+import { Account } from "./account.js";
+import type { InfoData, LocalInfoFilter, LocalMarkFilter, MarkData, MarkParam } from "./local.js";
+import { LocalInfo, LocalMark } from "./local.js";
+import type { TokenDataFilter, TokenTypeInfo } from "./token.js";
+export { Account, LocalInfo, LocalMark };
+export interface AccountOrMark_Address {
+    name_or_address?: string;
+    local_mark_first?: boolean;
+}
+export interface ManyAccountOrMark_Address {
+    entities: AccountOrMark_Address[];
+    check_all_founded?: boolean;
+}
+export declare const GetAccountOrMark_Address: (entity?: AccountOrMark_Address) => Promise<string | undefined>;
+export declare const GetManyAccountOrMark_Address: (entities: ManyAccountOrMark_Address) => Promise<string[]>;
+export declare const query_local_mark_list: (filter: LocalMarkFilter | undefined | null) => Promise<MarkData[]>;
+export declare const query_account_list: (filter?: AccountFilter) => Promise<AccountData[]>;
+export declare const query_local_info_list: (filter?: LocalInfoFilter) => Promise<InfoData[]>;
+export declare const query_local_token_list: (filter?: TokenDataFilter) => Promise<TokenTypeInfo[]>;
+export declare const query_local_mark: <T extends string | string[]>(name_or_address: T) => Promise<T extends string ? MarkData | undefined : (MarkData | undefined)[]>;
+export declare const query_local_info: <T extends string | string[]>(name?: T) => Promise<T extends string ? InfoData | undefined : (InfoData | undefined)[]>;
+export declare const query_local_info_default: <T extends string | string[]>(name?: T) => Promise<T extends string ? string | undefined : (string | undefined)[]>;
+export interface QueryAccount {
+    name_or_address?: string;
+    balance?: boolean;
+    coin?: {
+        cursor?: string | null | undefined;
+        limit?: number | null | undefined;
+    };
+    token_type?: string;
+    network?: ENTRYPOINT;
+}
+export interface QueryAccountResult {
+    name_or_address?: string;
+    address?: string;
+    balance?: CoinBalance;
+    coin?: PaginatedCoins;
+}
+export declare const query_account: (query: QueryAccount) => Promise<QueryAccountResult>;
+export type FaucetNetwork = ENTRYPOINT.Localnet | ENTRYPOINT.Testnet;
+export interface AccountOperation {
+    gen?: {
+        name?: string;
+        replaceExistName?: boolean;
+        m?: string | null;
+    };
+    faucet?: {
+        name_or_address?: string;
+        network: FaucetNetwork;
+    };
+    suspend?: {
+        name_or_address?: string;
+    };
+    resume?: {
+        address: string;
+        name?: string;
+    };
+    rename?: {
+        name_or_address?: string;
+        new_name: string;
+    };
+    swap_name?: {
+        name_or_address1?: string;
+        name_or_address2?: string;
+    };
+    transfer?: {
+        name_or_address_from?: string;
+        name_or_address_to?: string;
+        amount: number | string | bigint;
+        token_type?: string;
+        network?: ENTRYPOINT;
+    };
+    get?: {
+        name_or_address?: string;
+        balance_required: string | bigint | number;
+        token_type?: string;
+        network?: ENTRYPOINT;
+    };
+    signData?: {
+        name_or_address?: string;
+        data: string | Uint8Array;
+        data_encoding?: "utf8" | "base64" | "hex";
+    };
+    messenger?: {
+        name_or_account?: string;
+        m: string | null;
+    };
+}
+export interface AccountOperationResult {
+    gen?: {
+        address: string;
+        name?: string;
+        m?: string | null;
+    };
+    faucet?: {
+        name_or_address?: string;
+        result: FaucetCoinInfo[];
+        network: FaucetNetwork;
+    };
+    suspend?: {
+        name_or_address?: string;
+        success: boolean;
+    };
+    resume?: {
+        address: string;
+        name?: string;
+        success: boolean;
+    };
+    rename?: {
+        name_or_address?: string;
+        new_name: string;
+        success: boolean;
+    };
+    swap_name?: {
+        name_or_address1?: string;
+        name_or_address2?: string;
+        success: boolean;
+    };
+    transfer?: SuiTransactionBlockResponse;
+    get?: {
+        coin_address?: string;
+        name_or_address?: string;
+        balance_required: string | bigint | number;
+        token_type?: string;
+        network?: ENTRYPOINT;
+    };
+    signData?: {
+        name_or_address?: string;
+        signature: string;
+        publicKey: string;
+        address: string;
+    };
+    messenger?: {
+        name_or_account?: string;
+        m: string | null;
+    };
+}
+export declare const account_operation: (op: AccountOperation) => Promise<AccountOperationResult>;
+export interface LocalMarkOperation {
+    clear?: {
+        op: "clear";
+    };
+    add?: {
+        op: "add";
+        data: MarkParam[];
+    };
+    remove?: {
+        op: "remove";
+        names: string[];
+    };
+}
+export interface LocalMarkOperationResult {
+    clear?: boolean;
+    add?: MarkData[];
+    remove?: MarkData[];
+}
+export declare const local_mark_operation: (op: LocalMarkOperation) => Promise<LocalMarkOperationResult>;
+export interface LocalInfoOperation {
+    clear?: {
+        op: "clear";
+    };
+    add?: {
+        op: "add";
+        data: InfoData[];
+    };
+    remove?: {
+        op: "remove";
+        data: string[];
+    };
+    reset?: {
+        op: "reset";
+        name: string;
+        contents: string[];
+    };
+}
+export interface LocalInfoOperationResult {
+    success: boolean;
+}
+export declare const local_info_operation: (op: LocalInfoOperation) => Promise<LocalInfoOperationResult>;
+export interface FetchTokenInfoOperation {
+    tokenType?: string | null | undefined;
+    alias?: string;
+    network?: ENTRYPOINT;
+}
+export declare const fetch_token_info_operation: (op: FetchTokenInfoOperation) => Promise<TokenTypeInfo | undefined>;
+export * from "./account.js";
+export * from "./config.js";
+export * from "./local.js";
+export * from "./token.js";
+export * from "./wip.js";