wowok 1.8.2 → 2.1.9

package/dist/cjs/w/call/base.d.ts

@@ -0,0 +1,42 @@
+import type { SuiTransactionBlockResponse } from "../../client/index.js";
+import { Transaction } from "../../transactions/index.js";
+import type { CallEnv, CoinObject, CoinParam, NamedObject, PassportObject, TxAddress } from "../common.js";
+import type { ObjectBase, ObjectType } from "../query/object.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+import type { SubmissionCall } from "./passport.js";
+import type { PermissionIndexType } from "./permission.js";
+export type ObjectsOp = {
+    op: "set" | "add" | "remove";
+    objects: string[];
+} | {
+    op: "clear";
+};
+export interface ResponseData extends ObjectBase {
+    change: "created" | "mutated" | string;
+}
+export interface CallResponseError {
+    type: "error";
+    error: string;
+}
+export type CallResult = SubmissionCall | SuiTransactionBlockResponse | CallResponseError | ResponseData[] | undefined;
+export declare function isCallResultSubmission(result: CallResult): result is SubmissionCall;
+export declare function ResponseData(response: CallResult | undefined): ResponseData[];
+export declare class CallBase {
+    private newResource;
+    private traceMarkNew;
+    content: ObjectBase | undefined;
+    env_ready: boolean;
+    protected operate(_env: CallEnv, _tx: Transaction, _passport?: PassportObject, _submission?: GuardSubmissionToFill[]): Promise<void>;
+    protected prepare(env: CallEnv): Promise<void>;
+    call(_env: CallEnv): Promise<CallResult>;
+    private env_prepare;
+    call_with_submission(env: CallEnv, info: SubmissionCall, freezePassport?: boolean): Promise<SuiTransactionBlockResponse | undefined>;
+    protected check_guard_and_call(env: CallEnv, guards_needed: string[]): Promise<CallResult>;
+    protected check_permission_and_call(env: CallEnv, permission: string, permIndex: PermissionIndexType[], guards_needed: string[], checkOwner?: boolean, checkAdmin?: boolean): Promise<CallResult>;
+    protected check_passport(env: CallEnv, param: SubmissionCall, freezePassport?: boolean): Promise<SuiTransactionBlockResponse>;
+    protected exec(env: CallEnv): Promise<SuiTransactionBlockResponse>;
+    protected new_with_mark(env: CallEnv, tx: Transaction, type: ObjectType, object: TxAddress, named_new?: NamedObject, innerTags?: string[]): Promise<void>;
+    protected update_content(env: CallEnv, type: ObjectType, object?: string): Promise<void>;
+    protected sign_and_commit(env: CallEnv, tx: Transaction): Promise<SuiTransactionBlockResponse>;
+}
+export declare function getCoinParam(env: CallEnv, tx: Transaction, coin: CoinParam, coinType: string): Promise<CoinObject>;

package/dist/cjs/w/call/base.js

@@ -0,0 +1,363 @@
+"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 base_exports = {};
+__export(base_exports, {
+  CallBase: () => CallBase,
+  ResponseData: () => ResponseData,
+  getCoinParam: () => getCoinParam,
+  isCallResultSubmission: () => isCallResultSubmission
+});
+module.exports = __toCommonJS(base_exports);
+var import_client = require("../../client/index.js");
+var import_transactions = require("../../transactions/index.js");
+var import_sui_types = require("../../utils/sui-types.js");
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_lodash = __toESM(require("lodash"));
+var import_account = require("../local/account.js");
+var import_local = require("../local/local.js");
+var import_object = require("../query/object.js");
+var import_passport = require("./passport.js");
+var import_resource = require("./resource.js");
+var import_entity = require("./entity.js");
+var import_util = require("./util.js");
+var import_config = require("../local/config.js");
+function isCallResultSubmission(result) {
+  return result?.submission && result?.submission?.length > 0;
+}
+function ResponseData(response) {
+  if (response?.digest) {
+    const res = [];
+    response?.objectChanges?.forEach(
+      (v) => {
+        const type_raw = v?.objectType;
+        const type = (0, import_object.raw2type)(type_raw);
+        if (type) {
+          res.push({
+            type,
+            type_raw,
+            object: v?.objectId,
+            version: v?.version,
+            owner: v?.owner,
+            change: v.type
+          });
+        }
+      }
+    );
+    return res;
+  }
+  return [];
+}
+class CallBase {
+  constructor() {
+    // operation implementation for a call
+    __publicField(this, "newResource");
+    __publicField(this, "traceMarkNew", /* @__PURE__ */ new Map());
+    __publicField(this, "content");
+    __publicField(this, "env_ready", false);
+  }
+  async operate(_env, _tx, _passport, _submission) {
+  }
+  async prepare(env) {
+    await this.env_prepare(env);
+  }
+  // return WitnessFill to resolve filling witness, and than 'call_with_witness' to complete the call;
+  // return ResponseData when the call has completed;
+  // throw an exception when errors.
+  async call(_env) {
+    return void 0;
+  }
+  async env_prepare(env) {
+    if (this.env_ready) {
+      return;
+    }
+    await (0, import_util.resolveCallEnv)(env);
+    this.env_ready = true;
+  }
+  async call_with_submission(env, info, freezePassport) {
+    if (info.guard.length > 0) {
+      await this.prepare(env);
+      await this.check_passport(env, info, freezePassport);
+    }
+    return void 0;
+  }
+  async check_guard_and_call(env, guards_needed) {
+    env.permission_guard?.forEach((guard) => {
+      if (!(0, import_sui_types.isValidWowAddress)(guard)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidAddress,
+          `env permission_guard: ${guard}`
+        );
+      }
+      guards_needed.push(guard);
+    });
+    if (guards_needed.length > 0) {
+      const param = await (0, import_passport.get_guardSubmissions)(env, guards_needed);
+      if (param.submission.length > 0) {
+        return {
+          type: "submission",
+          guard: param.guard,
+          submission: param.submission
+        };
+      }
+      return await this.check_passport(env, param);
+    } else {
+      return await this.exec(env);
+    }
+  }
+  async check_permission_and_call(env, permission, permIndex, guards_needed, checkOwner, checkAdmin) {
+    let bAdmin = false;
+    const p = await (0, import_object.query_objects)({
+      objects: [permission],
+      no_cache: env.no_cache,
+      network: env.network
+    });
+    if (!p.objects?.[0] || p.objects?.[0].type !== "Permission") {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, "permission object not found");
+    }
+    const perm_object = p.objects?.[0];
+    const acc = await (0, import_util.getCallEnvAccount)(env);
+    bAdmin = perm_object.admin.includes(acc);
+    if (checkOwner && perm_object.builder !== acc)
+      (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, `${acc} owner permission required`);
+    if (checkAdmin && !bAdmin)
+      (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, `${acc} admin permission required`);
+    env.permission_guard?.forEach((guard) => {
+      if (!(0, import_sui_types.isValidWowAddress)(guard)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidAddress,
+          `env permission_guard ${guard}`
+        );
+      }
+      guards_needed.push(guard);
+    });
+    if (permIndex.length > 0 && !bAdmin) {
+      const addressesToCheck = [acc, ...env.permission_guard ?? []];
+      const permissionPromises = addressesToCheck.map(async (address) => {
+        const p2 = await (0, import_object.queryTableItem_PermissionPerm)({
+          parent: permission,
+          address,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+        if (p2 && p2.type === "TableItem_PermissionPerm") {
+          const perm = p2;
+          return { address, permissions: perm.perm };
+        }
+        return { address, permissions: [] };
+      });
+      const permissionResults = await Promise.all(permissionPromises);
+      const allAvailablePermissions = /* @__PURE__ */ new Set();
+      permissionResults.forEach((result) => {
+        result.permissions.forEach(
+          (perm) => allAvailablePermissions.add(perm)
+        );
+      });
+      const missingPermissions = permIndex.filter(
+        (perm) => !allAvailablePermissions.has(perm)
+      );
+      if (missingPermissions.length > 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.NoPermission,
+          `Missing permissions ${missingPermissions.join(", ")} in ${permission}`
+        );
+      }
+    }
+    if (guards_needed.length > 0) {
+      const param = await (0, import_passport.get_guardSubmissions)(env, guards_needed);
+      if (param.submission.length > 0) {
+        return {
+          type: "submission",
+          guard: param.guard,
+          submission: param.submission
+        };
+      }
+      return await this.check_passport(env, param);
+    } else {
+      return await this.exec(env);
+    }
+  }
+  async check_passport(env, param, freezePassport) {
+    const tx = new import_transactions.Transaction();
+    const passport = (0, import_passport.newPassport)(tx);
+    for (const v of param.guard) {
+      await (0, import_passport.guardAdd)(
+        tx,
+        passport,
+        v.object,
+        param.submission.find((i) => i.guard === v.object)?.submission ?? [],
+        v.impack
+      );
+    }
+    (0, import_passport.verify)(tx, passport);
+    await this.operate(env, tx, passport, param.submission);
+    if (freezePassport) {
+      (0, import_passport.freeze)(tx, passport);
+    } else {
+      (0, import_passport.destroy)(tx, passport);
+    }
+    return await this.sign_and_commit(env, tx);
+  }
+  async exec(env) {
+    const tx = new import_transactions.Transaction();
+    await this.operate(env, tx);
+    return await this.sign_and_commit(env, tx);
+  }
+  async new_with_mark(env, tx, type, object, named_new, innerTags = [import_resource.TagName.Launch]) {
+    const tags = named_new?.tags ? import_lodash.default.uniq([...named_new.tags, ...innerTags]) : import_lodash.default.uniq([...innerTags]);
+    if (named_new) {
+      named_new.tags = tags;
+      this.traceMarkNew.set(type, named_new);
+    }
+    if (!named_new?.onChain) return;
+    if (!this.newResource) {
+      let r;
+      try {
+        r = await (0, import_object.queryTableItem_EntityRegistrar)({
+          address: await (0, import_util.getCallEnvAccount)(env),
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      } catch (e) {
+      }
+      if (r && r.type !== "TableItem_EntityRegistrar") {
+        (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, "no entity registrar found");
+      }
+      if (r?.mark_object) {
+        (0, import_resource.addObjectTags)(tx, r.mark_object, {
+          address: object,
+          tags
+        });
+        return;
+      } else {
+        this.newResource = (0, import_entity.register_with_resource_forced)(
+          tx,
+          typeof env.referrer === "string" ? env.referrer : null
+          //@ referrer
+        );
+      }
+    }
+    if (this.newResource) {
+      (0, import_resource.addObjectTags)(tx, this.newResource, {
+        address: object,
+        tags
+      });
+    }
+  }
+  async update_content(env, type, object) {
+    if (this.content || !object) return;
+    const r = await (0, import_object.query_objects)({
+      objects: [object],
+      no_cache: env.no_cache,
+      network: env.network
+    });
+    if (!r.objects || r?.objects?.length !== 1 || r?.objects[0]?.type !== type) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.Fail, `Fetch ${type} object ${object} failed`);
+    }
+    this.content = r?.objects[0];
+  }
+  async sign_and_commit(env, tx) {
+    if (this.newResource) {
+      (0, import_resource.create)(tx, this.newResource);
+      this.newResource = void 0;
+    }
+    let r = await import_account.Account.Instance().sign_and_commit(
+      tx,
+      await (0, import_util.getCallEnvAccount)(env),
+      env.network
+    );
+    if (!r) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.Fail, "sign and commit failed");
+    }
+    if (r?.digest && !r?.objectChanges) {
+      const client = new import_client.SuiClient({
+        url: (0, import_client.getFullnodeUrl)(
+          await import_config.Config.Instance().network_get(env.network)
+        )
+      });
+      r = await client.getTransactionBlock({
+        digest: r?.digest,
+        options: { showObjectChanges: true }
+      });
+    }
+    const res = ResponseData(r);
+    for (let i = 0; i < res.length; ++i) {
+      const v = res[i];
+      if (v.type && v.change === "created") {
+        const namedNew = this.traceMarkNew.get(v.type);
+        if (namedNew) {
+          await import_local.LocalMark.Instance().put([
+            {
+              name: namedNew.name ? {
+                value: namedNew.name,
+                replaceExistName: namedNew.replaceExistName
+              } : void 0,
+              address: v.object,
+              tags: namedNew?.tags ? [...namedNew.tags, v.type] : [v.type]
+            }
+          ]);
+        }
+      }
+    }
+    return r;
+  }
+}
+async function getCoinParam(env, tx, coin, coinType) {
+  let coinParam;
+  if ("balance" in coin && coin.balance != null) {
+    if (!(0, import_common.isValidU64)(coin.balance)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.IsValidU64,
+        `Total pay balance ${coin.balance} is not valid`
+      );
+    }
+    coinParam = await import_account.Account.Instance().get_coin_object(
+      tx,
+      coin.balance,
+      coinType,
+      await (0, import_util.getCallEnvAccount)(env),
+      env.network
+    );
+  } else if ("coin" in coin && coin.coin != null) {
+    if (typeof coin.coin === "string") {
+      coinParam = await import_local.LocalMark.Instance().get_address(coin.coin);
+    } else {
+      coinParam = coin.coin;
+    }
+  }
+  if (!coinParam) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Total pay ${JSON.stringify(coin)} is allocated failed`
+    );
+  }
+  return (0, import_common.toTxObject)(tx, coinParam);
+}

package/dist/cjs/w/call/contact.d.ts

@@ -0,0 +1,45 @@
+import type { Transaction } from "../../transactions/index.js";
+import type { PassportObject, PermissionObject, WithPermissionObject, CallEnv, ContactObject, ContactAddress } from "../common.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+import type { ReceivedObjectsOrRecently } from "../query/received.js";
+export declare const MAX_IM_COUNT = 200;
+export interface ImParam {
+    at: string;
+    description?: string;
+}
+export interface CallContact_Data {
+    object: WithPermissionObject;
+    my_status?: string;
+    description?: string;
+    location?: string;
+    ims?: {
+        op: "add" | "set";
+        im: ImParam[];
+    } | {
+        op: "remove";
+        im: string[];
+    } | {
+        op: "clear";
+    };
+    owner_receive?: ReceivedObjectsOrRecently;
+}
+export declare class CallContact extends CallBase {
+    data: CallContact_Data;
+    object_address: string | undefined;
+    permission_address: string | undefined;
+    new_permission_description: string | undefined;
+    constructor(data: CallContact_Data);
+    protected prepare(env: CallEnv): Promise<void>;
+    call(env: CallEnv): Promise<CallResult>;
+    operate(env: CallEnv, tx: Transaction, passport?: PassportObject, submission?: GuardSubmissionToFill[]): Promise<void>;
+}
+export declare function create(tx: Transaction, contact: ContactObject): ContactAddress;
+export declare function change_status(tx: Transaction, contact: ContactObject, status: string): ContactAddress;
+export declare function newContact(tx: Transaction, permission: PermissionObject, description: string, passport?: PassportObject): ContactObject;
+export declare function description_set(tx: Transaction, contact: ContactObject, permission: PermissionObject, description: string, passport?: PassportObject): void;
+export declare function location_set(tx: Transaction, contact: ContactObject, permission: PermissionObject, location: string, passport?: PassportObject): void;
+export declare function im_add(tx: Transaction, contact: ContactObject, permission: PermissionObject, im: string, description?: string | null, passport?: PassportObject): void;
+export declare function im_remove(tx: Transaction, contact: ContactObject, permission: PermissionObject, im: string[], passport?: PassportObject): void;
+export declare function im_clear(tx: Transaction, contact: ContactObject, permission: PermissionObject, passport?: PassportObject): void;