wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,746 @@
+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 { Ed25519Keypair } from "../../keypairs/ed25519/index.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import {
+  GasTokenType,
+  isGasTokenType,
+  isValidName,
+  MAX_NAME_LENGTH
+} from "../common.js";
+import { getFaucetHost, requestSuiFromFaucetV2 } from "../../faucet/index.js";
+import { Transaction } from "../../transactions/index.js";
+import { getFullnodeUrl } from "../../client/network.js";
+import { SuiClient } from "../../client/index.js";
+import { Config } from "./config.js";
+import { SQLiteAccountStorage } from "./storage.js";
+import { isValidWowAddress } from "../../utils/sui-types.js";
+const DEFAULT_ACCOUNT_NAME = "";
+const MAX_MESSENGER_ACCOUNTS = 10;
+const _Account = class _Account {
+  constructor() {
+    // token_type is the platform token, if not specified.
+    __publicField(this, "balance", async (token_type, address_or_name, network) => {
+      const a = await this.get(address_or_name);
+      token_type = token_type ?? GasTokenType;
+      if (a) {
+        const client = new SuiClient({
+          url: getFullnodeUrl(
+            await Config.Instance().network_get(network)
+          )
+        });
+        return client.getBalance({
+          owner: a.address,
+          coinType: token_type
+        });
+      }
+      return void 0;
+    });
+    // token_type is the platform token, if not specified.
+    __publicField(this, "coin", async (token_type, cursor, limit, address_or_name, network) => {
+      const a = await this.get(address_or_name);
+      token_type = token_type ?? GasTokenType;
+      if (a) {
+        const client = new SuiClient({
+          url: getFullnodeUrl(
+            await Config.Instance().network_get(network)
+          )
+        });
+        return client.getCoins({
+          owner: a.address,
+          coinType: token_type,
+          cursor,
+          limit
+        });
+      }
+      return void 0;
+    });
+    __publicField(this, "get_coin_object", async (txb, balance_required, token_type, address_or_name, network) => {
+      const a = await this.get(address_or_name);
+      if (a) {
+        const b = BigInt(balance_required);
+        const client = new SuiClient({
+          url: getFullnodeUrl(
+            await Config.Instance().network_get(network)
+          )
+        });
+        if (b >= BigInt(0)) {
+          if (!token_type || isGasTokenType(token_type)) {
+            return txb.splitCoins(txb.gas, [b]);
+          } else {
+            const r = await client.getCoins({
+              owner: a.address,
+              coinType: token_type
+            });
+            const objects = [];
+            let current = BigInt(0);
+            for (let i = 0; i < r.data.length; ++i) {
+              current += BigInt(r.data[i].balance);
+              objects.push(r.data[i].coinObjectId);
+              if (current >= b) {
+                break;
+              }
+            }
+            if (objects.length === 1) {
+              return txb.splitCoins(objects[0], [b]);
+            } else {
+              const ret = objects.pop();
+              txb.mergeCoins(ret, objects);
+              return txb.splitCoins(ret, [b]);
+            }
+          }
+        }
+      }
+      return void 0;
+    });
+    __publicField(this, "get_many_coin_object", async (txb, balance_required, token_type, address_or_name, network) => {
+      const coinObjects = [];
+      for (const balance of balance_required) {
+        const coinObject = await this.get_coin_object(
+          txb,
+          balance,
+          address_or_name,
+          token_type,
+          network
+        );
+        if (!coinObject) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `Invalid coin object: ${balance}`
+          );
+        } else {
+          coinObjects.push(coinObject);
+        }
+      }
+      return txb.makeMoveVec({ elements: coinObjects });
+    });
+    __publicField(this, "coinObject_with_balance", async (balance_required, token_type, address_or_name, network) => {
+      const a = await this.get_imp(address_or_name);
+      if (!a) return void 0;
+      const pair = Ed25519Keypair.fromSecretKey(a.secret);
+      if (!pair) return void 0;
+      const txb = new Transaction();
+      const res = await this.get_coin_object(
+        txb,
+        balance_required,
+        token_type,
+        address_or_name,
+        network
+      );
+      if (res) {
+        txb.transferObjects([res], a.address);
+        const client = new SuiClient({
+          url: getFullnodeUrl(
+            await Config.Instance().network_get(network)
+          )
+        });
+        const r = await client.signAndExecuteTransaction({
+          transaction: txb,
+          signer: pair,
+          options: { showObjectChanges: true }
+        });
+        const t = token_type ?? GasTokenType;
+        return r?.objectChanges?.find(
+          (v) => v?.type === "created" && (v?.objectType).includes(t)
+        )?.objectId;
+      }
+      return void 0;
+    });
+  }
+  setStorage(storage) {
+    _Account.storage = storage;
+  }
+  /**
+   * 获取存储实例，如果未初始化则自动初始化
+   */
+  async getStorage() {
+    if (!_Account.storage) {
+      _Account.storage = new SQLiteAccountStorage();
+    }
+    return _Account.storage;
+  }
+  static Instance() {
+    if (!_Account._instance) {
+      _Account._instance = new _Account();
+    }
+    return _Account._instance;
+  }
+  accountData(data) {
+    if (!data || !data.secret) return void 0;
+    const r = Ed25519Keypair.fromSecretKey(data.secret);
+    data.pubkey = r.getPublicKey().toWPublicKey();
+    data.secret = void 0;
+    return data;
+  }
+  async gen(name, replaceExistName, m) {
+    name = this.name_resolve(name);
+    if (name && !isValidName(name)) {
+      W_ERROR(
+        WErrors.IsValidName,
+        `Name ${name} is exceeds max ${MAX_NAME_LENGTH}`
+      );
+    }
+    if (m && !isValidName(m)) {
+      W_ERROR(
+        WErrors.IsValidName,
+        `Messenger name ${m} is exceeds max ${MAX_NAME_LENGTH}`
+      );
+    }
+    const secret = Ed25519Keypair.generate().getSecretKey();
+    const address = Ed25519Keypair.fromSecretKey(secret).getPublicKey().toWAddress();
+    const now = Date.now();
+    const ret = {
+      name,
+      address,
+      secret,
+      m: m || void 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      const data = JSON.parse(value);
+      if (m) {
+        const messengerCount = data.filter((d) => d.m != null).length;
+        if (messengerCount >= MAX_MESSENGER_ACCOUNTS) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `Maximum ${MAX_MESSENGER_ACCOUNTS} messenger accounts allowed, current count: ${messengerCount}`
+          );
+        }
+      }
+      const found = data.findIndex((d) => d.name === name);
+      if (found !== -1) {
+        if (replaceExistName) {
+          data[found].name = void 0;
+          data.push(ret);
+          return this.accountData(ret);
+        } else {
+          W_ERROR(
+            WErrors.AccountNameExist,
+            `Name ${name || ""} already exist`
+          );
+        }
+      } else {
+        await storage.put(JSON.stringify([...data, ret]));
+      }
+    } else {
+      await storage.put(JSON.stringify([ret]));
+    }
+    return this.accountData(ret);
+  }
+  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));
+    }
+    return this.gen(address_or_name);
+  }
+  async get_address(address_or_name) {
+    if (address_or_name && isValidWowAddress(address_or_name)) {
+      return address_or_name;
+    }
+    return (await this.get_imp(address_or_name))?.address;
+  }
+  async get_many_address(address_or_names) {
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      const s = JSON.parse(value);
+      return address_or_names.map((i) => {
+        if (i && isValidWowAddress(i)) return i;
+        return s.find(
+          (v) => v.address === i || v.name === this.name_resolve(i)
+        )?.address;
+      });
+    }
+    return address_or_names.map(
+      (i) => i && isValidWowAddress(i) ? i : void 0
+    );
+  }
+  async get_imp(address_or_name) {
+    address_or_name = this.name_resolve(address_or_name);
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      return JSON.parse(value).find(
+        (d) => d.name === address_or_name || d.address === address_or_name
+      );
+    }
+    return void 0;
+  }
+  name_resolve(address_or_name) {
+    return address_or_name || DEFAULT_ACCOUNT_NAME;
+  }
+  async get_many_imp(address_or_names) {
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      const s = JSON.parse(value);
+      return address_or_names.map((i) => {
+        return s.find(
+          (v) => v.address === i || v.name === this.name_resolve(i)
+        );
+      });
+    }
+    return address_or_names.map((_) => void 0);
+  }
+  async swap_name(name1, name2) {
+    name1 = this.name_resolve(name1);
+    name2 = this.name_resolve(name2);
+    if (name1 === name2) return true;
+    if (!isValidName(name1)) {
+      W_ERROR(
+        WErrors.IsValidName,
+        `Name ${name1} is exceeds max ${MAX_NAME_LENGTH}`
+      );
+    }
+    if (!isValidName(name2)) {
+      W_ERROR(
+        WErrors.IsValidName,
+        `Name ${name2} is exceeds max ${MAX_NAME_LENGTH}`
+      );
+    }
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (!value) return false;
+    const data = JSON.parse(value);
+    const f1 = data.find((d) => d.name === name1);
+    const f2 = data.find((d) => d.name === name2);
+    if (!f1 || !f2) return false;
+    const now = Date.now();
+    f1.name = name2;
+    f1.updatedAt = now;
+    f2.name = name1;
+    f2.updatedAt = now;
+    await storage.put(JSON.stringify(data));
+    return true;
+  }
+  async rename(name, address_or_name) {
+    name = this.name_resolve(name);
+    address_or_name = this.name_resolve(address_or_name);
+    if (address_or_name === name) return true;
+    if (address_or_name && !isValidName(address_or_name)) {
+      W_ERROR(
+        WErrors.IsValidName,
+        `Name ${address_or_name} is exceeds max ${MAX_NAME_LENGTH}`
+      );
+    }
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      const data = JSON.parse(value);
+      if (data.find((d) => d.name === name)) {
+        W_ERROR(WErrors.IsValidName, `Name "${name}" already exists`);
+      }
+      const f = data.find((d) => d.name === address_or_name);
+      if (!f) return false;
+      const now = Date.now();
+      f.name = name;
+      f.updatedAt = now;
+      await storage.put(JSON.stringify(data));
+      return true;
+    }
+    return false;
+  }
+  async list(filter) {
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      let accounts = JSON.parse(value);
+      if (filter?.suspended !== void 0) {
+        accounts = accounts.filter(
+          (v) => filter.suspended ? v.suspended === true : !v.suspended
+        );
+      } else {
+        accounts = accounts.filter((v) => !v.suspended);
+      }
+      if (filter?.hasMessenger !== void 0) {
+        accounts = accounts.filter(
+          (v) => filter.hasMessenger ? v.m != null : v.m == null
+        );
+      }
+      if (filter?.m != null) {
+        accounts = accounts.filter((v) => v.m != null);
+      }
+      if (filter?.createdAt) {
+        if (filter.createdAt.gte !== void 0) {
+          accounts = accounts.filter(
+            (v) => v.createdAt && v.createdAt >= filter.createdAt.gte
+          );
+        }
+        if (filter.createdAt.lte !== void 0) {
+          accounts = accounts.filter(
+            (v) => v.createdAt && v.createdAt <= filter.createdAt.lte
+          );
+        }
+      }
+      if (filter?.updatedAt) {
+        if (filter.updatedAt.gte !== void 0) {
+          accounts = accounts.filter(
+            (v) => v.updatedAt && v.updatedAt >= filter.updatedAt.gte
+          );
+        }
+        if (filter.updatedAt.lte !== void 0) {
+          accounts = accounts.filter(
+            (v) => v.updatedAt && v.updatedAt <= filter.updatedAt.lte
+          );
+        }
+      }
+      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;
+            } else if (lowerName.startsWith(lowerFilterName)) {
+              score += 50;
+            } else if (lowerName.includes(lowerFilterName)) {
+              score += 25;
+            }
+          }
+          if (filter?.address) {
+            const lowerAddress = account.address.toLowerCase();
+            const lowerFilterAddress = filter.address.toLowerCase();
+            if (lowerAddress === lowerFilterAddress) {
+              score += 100;
+            } else if (lowerAddress.startsWith(lowerFilterAddress)) {
+              score += 50;
+            } else if (lowerAddress.includes(lowerFilterAddress)) {
+              score += 25;
+            }
+          }
+          if (filter?.m != null && account.m != null) {
+            const lowerM = account.m.toLowerCase();
+            const lowerFilterM = filter.m.toLowerCase();
+            if (lowerM === lowerFilterM) {
+              score += 100;
+            } else if (lowerM.startsWith(lowerFilterM)) {
+              score += 50;
+            } else if (lowerM.includes(lowerFilterM)) {
+              score += 25;
+            }
+          }
+          if ((filter?.name || filter?.address || filter?.m != null) && score === 0) {
+            score = -1;
+          }
+          return { account, score };
+        }).filter(({ score }) => score >= 0).sort((a, b) => b.score - a.score).map(({ account }) => account);
+      }
+      return accounts.map((v) => this.accountData(v)).filter((v) => v !== void 0);
+    }
+    return [];
+  }
+  async suspend(address_or_name) {
+    address_or_name = this.name_resolve(address_or_name);
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      const s = JSON.parse(value);
+      const f = s.find(
+        (v) => v.address === address_or_name || v.name === address_or_name
+      );
+      if (f) {
+        const now = Date.now();
+        f.suspended = true;
+        f.name = void 0;
+        f.updatedAt = now;
+        await storage.put(JSON.stringify(s));
+        return true;
+      }
+    }
+    return false;
+  }
+  async suspend_many(address_or_names) {
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    const result = { success: [], failed: [] };
+    if (value) {
+      const s = JSON.parse(value);
+      const now = Date.now();
+      let modified = false;
+      for (const address_or_name of address_or_names) {
+        const resolved = this.name_resolve(address_or_name);
+        const f = s.find(
+          (v) => v.address === resolved || v.name === resolved
+        );
+        if (f) {
+          f.suspended = true;
+          f.name = void 0;
+          f.updatedAt = now;
+          result.success.push(address_or_name);
+          modified = true;
+        } else {
+          result.failed.push(address_or_name);
+        }
+      }
+      if (modified) {
+        await storage.put(JSON.stringify(s));
+      }
+    } else {
+      result.failed = [...address_or_names];
+    }
+    return result;
+  }
+  async resume(address, name) {
+    name = this.name_resolve(name);
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (value) {
+      const s = JSON.parse(value);
+      if (s.find((v) => v.name === name)) {
+        W_ERROR(WErrors.IsValidName, `Name "${name}" already exists`);
+      }
+      const f = s.find((v) => v.address === address);
+      if (f) {
+        const now = Date.now();
+        f.suspended = false;
+        f.name = name;
+        f.updatedAt = now;
+        await storage.put(JSON.stringify(s));
+        return true;
+      }
+    }
+    return false;
+  }
+  async faucet(address_or_name, network) {
+    const a = await this.get_imp(address_or_name);
+    if (a) {
+      try {
+        const r = await requestSuiFromFaucetV2({
+          host: getFaucetHost(network),
+          recipient: a.address
+        });
+        return r.coins_sent || [];
+      } catch (_e) {
+      }
+    }
+    return [];
+  }
+  async sign_and_commit(tx, address_or_name, network) {
+    const a = await this.get_imp(address_or_name);
+    if (a) {
+      const pair = Ed25519Keypair.fromSecretKey(a.secret);
+      if (pair) {
+        const client = new SuiClient({
+          url: getFullnodeUrl(
+            await Config.Instance().network_get(network)
+          )
+        });
+        return client.signAndExecuteTransaction({
+          transaction: tx,
+          signer: pair,
+          options: { showObjectChanges: true, showEffects: true }
+        });
+      }
+    }
+    return void 0;
+  }
+  async refund_coin(txb, coin, to_address_or_name) {
+    const to = await this.get_address(to_address_or_name);
+    if (!to)
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Invalid to address or name ${to_address_or_name}`
+      );
+    txb.transferObjects(
+      [coin],
+      txb.pure.address(to)
+    );
+  }
+  async transfer(amount, token_type, to_address_or_name, from_address_or_name, network) {
+    const [from, to] = await this.get_many_imp([
+      from_address_or_name,
+      to_address_or_name
+    ]);
+    if (!from)
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Invalid from address or name ${from_address_or_name}`
+      );
+    const to_address = to?.address ?? to_address_or_name;
+    if (!to_address)
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Invalid to address or name ${to_address_or_name}`
+      );
+    const pair = Ed25519Keypair.fromSecretKey(from.secret);
+    if (pair) {
+      const txb = new Transaction();
+      const coin = await this.get_coin_object(
+        txb,
+        amount,
+        token_type,
+        from_address_or_name,
+        network
+      );
+      if (coin) {
+        txb.transferObjects(
+          [coin],
+          to_address
+        );
+        const client = new SuiClient({
+          url: getFullnodeUrl(
+            await Config.Instance().network_get(network)
+          )
+        });
+        const r = client.signAndExecuteTransaction({
+          transaction: txb,
+          signer: pair,
+          options: { showObjectChanges: true }
+        });
+        return r;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 使用账户私钥对数据进行签名
+   *
+   * @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) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Account not found or no secret key: ${address_or_name}`
+      );
+    }
+    const pair = Ed25519Keypair.fromSecretKey(account.secret);
+    const dataBytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    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) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Account not found or no secret key: ${address_or_name}`
+      );
+    }
+    const pair = Ed25519Keypair.fromSecretKey(account.secret);
+    const dataBytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const signature = await pair.sign(dataBytes);
+    return {
+      signature: "0x" + Buffer.from(signature).toString("hex"),
+      publicKey: pair.getPublicKey().toWPublicKey(),
+      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}`
+      );
+    }
+    const ed25519SecretKey = account.secret;
+    const { sha512 } = await import("@noble/hashes/sha512");
+    const hash = sha512(ed25519SecretKey);
+    const privateKey = new Uint8Array(hash.slice(0, 32));
+    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();
+    const value = await storage.get();
+    if (!value) return false;
+    const data = JSON.parse(value);
+    const f = data.find(
+      (v) => v.address === resolved_address_or_name || v.name === resolved_address_or_name
+    );
+    if (!f) return false;
+    if (m) {
+      if (!isValidName(m)) {
+        W_ERROR(
+          WErrors.IsValidName,
+          `Messenger name ${m} is exceeds max ${MAX_NAME_LENGTH}`
+        );
+      }
+      const currentCount = data.filter(
+        (d) => d.m != null && d.address !== f.address
+      ).length;
+      if (currentCount >= MAX_MESSENGER_ACCOUNTS) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Maximum ${MAX_MESSENGER_ACCOUNTS} messenger accounts allowed, current count: ${currentCount}`
+        );
+      }
+    }
+    const now = Date.now();
+    f.m = m || void 0;
+    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
+   */
+  async count_messenger_accounts() {
+    const storage = await this.getStorage();
+    const value = await storage.get();
+    if (!value) return 0;
+    const data = JSON.parse(value);
+    return data.filter((d) => d.m != null).length;
+  }
+};
+__publicField(_Account, "_instance");
+__publicField(_Account, "storage");
+let Account = _Account;
+export {
+  Account,
+  DEFAULT_ACCOUNT_NAME,
+  MAX_MESSENGER_ACCOUNTS
+};