wowok 1.8.3 → 2.1.9

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

@@ -0,0 +1,301 @@
+import { GasCoinType } from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { Account } from "./account.js";
+import { LocalInfo, LocalInfoNameDefault, LocalMark } from "./local.js";
+import { TokenInfo } from "./token.js";
+const GetAccountOrMark_Address = async (entity) => {
+  if (!entity || !entity?.name_or_address) {
+    return await Account.Instance().get_address(void 0);
+  }
+  if (entity?.local_mark_first) {
+    const r = await LocalMark.Instance().get_address(
+      entity?.name_or_address
+    );
+    if (!r) {
+      return await Account.Instance().get_address(
+        entity?.name_or_address
+      );
+    }
+    return r;
+  } else {
+    const r = await Account.Instance().get_address(entity?.name_or_address);
+    if (!r) {
+      return await LocalMark.Instance().get_address(
+        entity?.name_or_address
+      );
+    }
+    return r;
+  }
+};
+const GetManyAccountOrMark_Address = async (entities) => {
+  const res = [];
+  for (let i = 0; i < entities.entities.length; ++i) {
+    const addr = await GetAccountOrMark_Address(entities.entities[i]);
+    if (!addr && entities.check_all_founded) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `entity ${entities.entities[i]?.name_or_address} is not a valid address, account or mark`
+      );
+    }
+    if (entities.check_all_founded && !addr) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `entity ${entities.entities[i]?.name_or_address} is not a valid address, account or mark`
+      );
+    }
+    if (addr) {
+      res.push(addr);
+    }
+  }
+  return res;
+};
+const query_local_mark_list = async (filter) => {
+  return await LocalMark.Instance().list(filter);
+};
+const query_account_list = async (filter) => {
+  return await Account.Instance().list(filter);
+};
+const query_local_info_list = async (filter) => {
+  return await LocalInfo.Instance().list(filter);
+};
+const query_local_token_list = async (filter) => {
+  return await TokenInfo.Instance().list(filter);
+};
+const query_local_mark = async (name_or_address) => {
+  if (typeof name_or_address === "string") {
+    return await LocalMark.Instance().get(name_or_address);
+  } else if (Array.isArray(name_or_address)) {
+    return await LocalMark.Instance().get_many(name_or_address);
+  }
+  return void 0;
+};
+const query_local_info = async (name = LocalInfoNameDefault) => {
+  if (typeof name === "string") {
+    return await LocalInfo.Instance().get(name);
+  } else if (Array.isArray(name)) {
+    return await LocalInfo.Instance().get_many(name);
+  }
+  return void 0;
+};
+const query_local_info_default = async (name = LocalInfoNameDefault) => {
+  if (typeof name === "string") {
+    return await LocalInfo.Instance().get_default(name);
+  } else if (Array.isArray(name)) {
+    return (await LocalInfo.Instance().get_many(name)).map(
+      (item) => item?.default
+    );
+  }
+  return void 0;
+};
+const query_account = async (query) => {
+  const r = await Account.Instance().get(query.name_or_address);
+  if (!r) {
+    return { name_or_address: query.name_or_address };
+  }
+  const res = {
+    address: r.address,
+    name_or_address: r.name
+  };
+  const token_type_ = query.token_type ?? GasCoinType;
+  if (query?.balance) {
+    res.balance = await Account.Instance().balance(
+      token_type_,
+      r.address,
+      query.network
+    );
+  } else if (query?.coin) {
+    res.coin = await Account.Instance().coin(
+      token_type_,
+      query.coin.cursor,
+      query.coin.limit,
+      r.address,
+      query.network
+    );
+  }
+  return res;
+};
+const account_operation = async (op) => {
+  var res = {};
+  if (op.gen != null) {
+    const acc = await Account.Instance().gen(
+      op.gen?.name,
+      op.gen?.replaceExistName,
+      op.gen?.m
+    );
+    res.gen = { address: acc?.address, name: acc?.name, m: acc?.m };
+  }
+  if (op.faucet != null) {
+    res.faucet = {
+      name_or_address: op.faucet.name_or_address,
+      result: await Account.Instance().faucet(
+        op.faucet.name_or_address,
+        op.faucet.network
+      ),
+      network: op.faucet.network
+    };
+  }
+  if (op.suspend != null) {
+    res.suspend = {
+      name_or_address: op.suspend.name_or_address,
+      success: await Account.Instance().suspend(
+        op.suspend.name_or_address
+      )
+    };
+  }
+  if (op.resume != null) {
+    res.resume = {
+      address: op.resume.address,
+      name: op.resume.name,
+      success: await Account.Instance().resume(
+        op.resume.address,
+        op.resume.name
+      )
+    };
+  }
+  if (op.rename != null) {
+    res.rename = {
+      name_or_address: op.rename.name_or_address,
+      new_name: op.rename.new_name,
+      success: await Account.Instance().rename(
+        op.rename.new_name,
+        op.rename.name_or_address
+      )
+    };
+  }
+  if (op.swap_name != null) {
+    res.swap_name = {
+      name_or_address1: op.swap_name.name_or_address1,
+      name_or_address2: op.swap_name.name_or_address2,
+      success: await Account.Instance().swap_name(
+        op.swap_name.name_or_address1,
+        op.swap_name.name_or_address2
+      )
+    };
+  }
+  if (op.transfer != null) {
+    const {
+      name_or_address_from,
+      name_or_address_to,
+      amount,
+      token_type,
+      network
+    } = op.transfer;
+    res.transfer = await Account.Instance().transfer(
+      amount,
+      token_type,
+      name_or_address_to,
+      name_or_address_from,
+      network
+    );
+  }
+  if (op.get != null) {
+    const { balance_required, token_type, name_or_address, network } = op.get;
+    res.get = {
+      name_or_address,
+      balance_required,
+      token_type,
+      network,
+      coin_address: await Account.Instance().coinObject_with_balance(
+        balance_required,
+        token_type,
+        name_or_address,
+        network
+      )
+    };
+  }
+  if (op.signData != null) {
+    const { name_or_address, data, data_encoding } = op.signData;
+    let dataToSign = data;
+    if (typeof data === "string" && data_encoding) {
+      switch (data_encoding) {
+        case "base64":
+          dataToSign = Uint8Array.from(Buffer.from(data, "base64"));
+          break;
+        case "hex":
+          dataToSign = Uint8Array.from(
+            Buffer.from(data.replace(/^0x/, ""), "hex")
+          );
+          break;
+        case "utf8":
+        default:
+          dataToSign = data;
+          break;
+      }
+    }
+    const signResult = await Account.Instance().signData(
+      name_or_address,
+      dataToSign
+    );
+    res.signData = {
+      name_or_address,
+      signature: signResult.signature,
+      publicKey: signResult.publicKey,
+      address: signResult.address
+    };
+  }
+  if (op.messenger != null) {
+    const { name_or_account, m } = op.messenger;
+    await Account.Instance().set_messenger(name_or_account, m);
+    res.messenger = { name_or_account, m };
+  }
+  return res;
+};
+const local_mark_operation = async (op) => {
+  const res = {};
+  if (op.clear) {
+    res.clear = await LocalMark.Instance().clear();
+  } else if (op.add) {
+    res.add = await LocalMark.Instance().put(op.add.data);
+  } else if (op.remove) {
+    res.remove = await LocalMark.Instance().del(op.remove.names);
+  }
+  return res;
+};
+const local_info_operation = async (op) => {
+  if (op.clear) {
+    await LocalInfo.Instance().clear();
+  } else if (op.add) {
+    await LocalInfo.Instance().add(op.add.data);
+  } else if (op.remove) {
+    await Promise.all(
+      op.remove.data.map((name) => LocalInfo.Instance().del(name))
+    );
+  } else if (op.reset) {
+    await LocalInfo.Instance().reset_contents(
+      op.reset.name,
+      op.reset.contents
+    );
+  }
+  return { success: true };
+};
+const fetch_token_info_operation = async (op) => {
+  return await TokenInfo.Instance().fetch(
+    op.tokenType,
+    op?.alias,
+    op?.network
+  );
+};
+export * from "./account.js";
+export * from "./config.js";
+export * from "./local.js";
+export * from "./token.js";
+export * from "./wip.js";
+export {
+  Account,
+  GetAccountOrMark_Address,
+  GetManyAccountOrMark_Address,
+  LocalInfo,
+  LocalMark,
+  account_operation,
+  fetch_token_info_operation,
+  local_info_operation,
+  local_mark_operation,
+  query_account,
+  query_account_list,
+  query_local_info,
+  query_local_info_default,
+  query_local_info_list,
+  query_local_mark,
+  query_local_mark_list,
+  query_local_token_list
+};

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

@@ -0,0 +1,93 @@
+export declare const BUITIN_IDS: string[];
+export declare const isValidAddress: (address: string | null | undefined) => boolean | "" | null | undefined;
+export interface MarkParam {
+    name?: {
+        value: string;
+        replaceExistName?: boolean;
+    };
+    address: string;
+    tags?: string[];
+}
+export interface MarkData {
+    name?: string;
+    address: string;
+    tags?: string[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface InfoDataInner {
+    default: string;
+    contents?: string[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface InfoData extends InfoDataInner {
+    name: string;
+}
+export interface LocalMarkFilter {
+    name?: string;
+    tags?: string[];
+    address?: string;
+    createdAt?: {
+        gte?: number;
+        lte?: number;
+    };
+    updatedAt?: {
+        gte?: number;
+        lte?: number;
+    };
+}
+export interface LocalInfoFilter {
+    name?: string;
+    default?: string;
+    contents?: string[];
+    createdAt?: {
+        gte?: number;
+        lte?: number;
+    };
+    updatedAt?: {
+        gte?: number;
+        lte?: number;
+    };
+}
+export declare const LocalMarkNameMaxLength = 64;
+export declare const LocalMarkTagMaxLength = 64;
+export declare const LocalMarkTagMaxCount = 50;
+export declare const LocalInfoNameMaxLength = 64;
+export declare const LocalInfoContentMaxLength = 300;
+export declare const LocalInfoContentMaxCount = 50;
+export declare const LocalInfoNameDefault = "Address of delivery";
+export declare class LocalMark {
+    static _instance: any;
+    private cacheKey;
+    static Instance(): LocalMark;
+    private resolve_tags;
+    private resolve_name;
+    put(marks: MarkParam[]): Promise<MarkData[]>;
+    get(name_or_address: string | undefined | null): Promise<MarkData | undefined>;
+    get_address(name_or_address: string | undefined | null): Promise<string | undefined>;
+    get_many(name_or_address: (string | null | undefined)[]): Promise<(MarkData | undefined)[]>;
+    get_many_address(name_or_address: (string | null | undefined)[]): Promise<(string | undefined)[]>;
+    get_many_address_availables(name_or_addresses: (string | null | undefined)[]): Promise<string[]>;
+    del(name_or_address: string[], delNotNamed?: boolean): Promise<MarkData[]>;
+    clear(): Promise<boolean>;
+    rename(name: string, new_name: string): Promise<boolean>;
+    swap_name(name1: string, name2: string): Promise<boolean>;
+    set_tags(name: string, tags: string[] | undefined): Promise<boolean>;
+    list(filter: LocalMarkFilter | undefined | null): Promise<MarkData[]>;
+}
+export declare class LocalInfo {
+    static _instance: any;
+    private cacheKey;
+    static Instance(): LocalInfo;
+    private resolve_contents;
+    private resolve_name;
+    add(data: InfoData[]): Promise<boolean>;
+    get(name?: string): Promise<InfoData | undefined>;
+    get_default(name?: string): Promise<string | undefined>;
+    get_many(names: string[]): Promise<(InfoData | undefined)[]>;
+    del(name?: string): Promise<void>;
+    reset_contents(name: string | undefined, contents: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+    list(filter?: LocalInfoFilter): Promise<InfoData[]>;
+}