wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,479 @@
+"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 contact_exports = {};
+__export(contact_exports, {
+  CallContact: () => CallContact,
+  MAX_IM_COUNT: () => MAX_IM_COUNT,
+  change_status: () => change_status,
+  create: () => create,
+  description_set: () => description_set,
+  im_add: () => im_add,
+  im_clear: () => im_clear,
+  im_remove: () => im_remove,
+  location_set: () => location_set,
+  newContact: () => newContact
+});
+module.exports = __toCommonJS(contact_exports);
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_object = require("../query/object.js");
+var import_base = require("./base.js");
+var import_permission = require("./permission.js");
+var import_permission2 = require("./permission.js");
+var import_util = require("../util.js");
+var import_local = require("../local/index.js");
+var import_received = require("../query/received.js");
+var import_sui_types = require("../../utils/sui-types.js");
+const MAX_IM_COUNT = 200;
+class CallContact extends import_base.CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "permission_address");
+    __publicField(this, "new_permission_description");
+    this.data = data;
+  }
+  async prepare(env) {
+    await super.prepare(env);
+    if (!this.object_address) {
+      this.object_address = await (0, import_common.GetObjectExisted)(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        import_object.ObjectType.Machine,
+        this.object_address
+      );
+      if (!this.content)
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallContact_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      if (!this.permission_address) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallContact_Data.data.object.permission is empty"
+        );
+      }
+    } else {
+      const n = (0, import_common.GetObject)(this.data.object);
+      this.permission_address = await (0, import_common.GetObjectExisted)(n?.permission);
+      this.new_permission_description = (0, import_common.GetObjectDescription)(
+        n?.permission
+      );
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const perms = [];
+    const guards = [];
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    const content = this.content;
+    if (this.data?.my_status != null) {
+      if (!content || !content.ims.filter((i) => i.at === env.account)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallContact_Data.data.my_status: your account not in im list"
+        );
+      }
+    }
+    if (this.permission_address && !this.object_address) {
+      add_perm(import_permission.BuiltinPermissionIndex.MESSNGER_NEW);
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(import_permission.BuiltinPermissionIndex.MESSNGER_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.location !== void 0) {
+      add_perm(import_permission.BuiltinPermissionIndex.MESSNGER_LOCATION);
+    }
+    if (this.permission_address && this.data.ims != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.MESSNGER_IM);
+    }
+    if (this.permission_address && this.data?.owner_receive) {
+      add_perm(import_permission.BuiltinPermissionIndex.MESSNGER_OWNER_RECEIVE);
+    }
+    if (this.permission_address || guards.length > 0) {
+      return await this.check_permission_and_call(
+        env,
+        this.permission_address,
+        perms,
+        guards
+      );
+    }
+    return await this.exec(env);
+  }
+  async operate(env, tx, passport, submission) {
+    let permission = this.permission_address;
+    let object = this.object_address;
+    const content = this.content;
+    if (!this.object_address) {
+      if (!permission) {
+        permission = (0, import_permission.newPermission)(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission) {
+        object = newContact(
+          tx,
+          (0, import_common.toTxObject)(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        "CallContact_Data.data.object:" + this.object_address
+      );
+    }
+    if (this.data?.my_status != null) {
+      change_status(tx, object, this.data.my_status);
+    }
+    if (this.data?.description != null && this.object_address) {
+      description_set(
+        tx,
+        object,
+        permission,
+        this.data.description,
+        passport
+      );
+    }
+    if (this.data?.location != null) {
+      location_set(
+        tx,
+        object,
+        permission,
+        this.data.location,
+        passport
+      );
+    }
+    if (this.data?.ims != null) {
+      switch (this.data.ims.op) {
+        case "add":
+        case "set": {
+          if (this.data.ims.im.length > MAX_IM_COUNT - (content?.ims?.length ?? 0)) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `CallContact_Data.data.ims.im exceeds max count:${MAX_IM_COUNT}`
+            );
+          }
+          if (this.data.ims.op === "set") {
+            im_clear(tx, object, permission, passport);
+          }
+          const r = await import_local.Account.Instance().get_many_address(
+            this.data.ims.im.map((x) => x.at)
+          );
+          const notFound = this.data.ims.im.filter((_, index) => r[index] === void 0).map((x) => x.at);
+          if (notFound.length > 0) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.AddressNotFound,
+              `Address not found: ${notFound.join(", ")}`
+            );
+          }
+          for (let i = 0; i < r.length; i++) {
+            const addr = r[i];
+            if (addr) {
+              const imParam = this.data.ims.im[i];
+              im_add(
+                tx,
+                object,
+                permission,
+                addr,
+                imParam?.description,
+                passport
+              );
+            }
+          }
+          break;
+        }
+        case "remove": {
+          const r = await import_local.Account.Instance().get_many_address(
+            this.data.ims.im
+          );
+          const notFound = this.data.ims.im.filter(
+            (_, index) => r[index] === void 0
+          );
+          if (notFound.length > 0) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.AddressNotFound,
+              `Address not found: ${notFound.join(", ")}`
+            );
+          }
+          im_remove(
+            tx,
+            object,
+            permission,
+            r.filter((x) => x != null),
+            passport
+          );
+          break;
+        }
+        case "clear":
+          im_clear(tx, object, permission, passport);
+          break;
+      }
+    }
+    if (this.data.owner_receive != null && this.object_address) {
+      if (this.data.owner_receive === "recently") {
+        this.data.owner_receive = await (0, import_received.query_received)({
+          object: this.object_address,
+          all_type: true,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      }
+      await (0, import_util.owner_receive)(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        void 0,
+        (name) => `${import_common.PackageAddress}::contact::${name}`,
+        passport
+      );
+    }
+    if (!this.permission_address) {
+      const p = (0, import_common.GetObject)(this.data?.object);
+      await this.new_with_mark(
+        env,
+        tx,
+        import_object.ObjectType.Permission,
+        (0, import_permission2.create)(tx, permission),
+        (0, import_common.GetObject)(p.permission)
+      );
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        import_object.ObjectType.Contact,
+        create(tx, object),
+        (0, import_common.GetObject)(this.data?.object)
+      );
+    }
+  }
+}
+function create(tx, contact) {
+  return tx.moveCall({
+    target: (0, import_common.contactFn)("create"),
+    arguments: [(0, import_common.toTxObject)(tx, contact)]
+  });
+}
+function change_status(tx, contact, status) {
+  if (!(0, import_common.isValidName)(status)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Status name(${status}) exceeds the length limit(${import_common.MAX_NAME_LENGTH})`
+    );
+  }
+  return tx.moveCall({
+    target: (0, import_common.contactFn)("change_status"),
+    arguments: [(0, import_common.toTxObject)(tx, contact), tx.pure.string(status)]
+  });
+}
+function newContact(tx, permission, description, passport) {
+  (0, import_util.validObjects)([permission]);
+  if (!(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length(${import_common.MAX_DESCRIPTION_LENGTH})`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: (0, import_common.contactFn)("new_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.string(description),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: (0, import_common.contactFn)("new"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.string(description),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function description_set(tx, contact, permission, description, passport) {
+  (0, import_util.validObjects)([contact, permission]);
+  if (!(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length(${import_common.MAX_DESCRIPTION_LENGTH})`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("description_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.string(description)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("description_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.string(description)
+      ]
+    });
+  }
+}
+function location_set(tx, contact, permission, location, passport) {
+  (0, import_util.validObjects)([contact, permission]);
+  if (!(0, import_common.isValidLongName)(location)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidLocation,
+      `Location exceeds maximum length(${import_common.MAX_LONG_NAME_LENGTH})`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("location_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.string(location)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("location_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.string(location)
+      ]
+    });
+  }
+}
+function im_add(tx, contact, permission, im, description, passport) {
+  (0, import_util.validObjects)([contact, permission]);
+  if (!(0, import_sui_types.isValidWowAddress)(im)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `IM address(${im}) is not a valid address`
+    );
+  }
+  if (description && !(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length(${import_common.MAX_DESCRIPTION_LENGTH})`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("im_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.address(im),
+        tx.pure.option("string", description),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("im_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.address(im),
+        tx.pure.option("string", description),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function im_remove(tx, contact, permission, im, passport) {
+  if (im.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([contact, permission]);
+  (0, import_common.isValidArray)(im, (item) => {
+    if (!(0, import_sui_types.isValidWowAddress)(item)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `IM address(${item}) is not a valid address`
+      );
+      return false;
+    }
+    return true;
+  });
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("im_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", im)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("im_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", im)
+      ]
+    });
+  }
+}
+function im_clear(tx, contact, permission, passport) {
+  (0, import_util.validObjects)([contact, permission]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("im_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, contact),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.contactFn)("im_clear"),
+      arguments: [(0, import_common.toTxObject)(tx, contact), (0, import_common.toTxObject)(tx, permission)]
+    });
+  }
+}

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

@@ -0,0 +1,79 @@
+import type { Transaction } from "../../transactions/index.js";
+import type { DemandObject, DemandAddress, TxString, ObjectResult, PassportObject, PermissionObject, GuardObject, ServiceObject, WithPermissionObject, CallEnv } from "../common.js";
+import type { AccountOrMark_Address } from "../local/index.js";
+import type { ServiceGuard } from "../query/object.js";
+import type { ReceivedObjectsOrRecently } from "../query/received.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+export interface DemandPresent {
+    recommend: string;
+    by_guard?: string;
+    service?: string;
+}
+export interface ServiceInfo {
+    recommend: string;
+    service: string | undefined;
+    update_time: number;
+    acceptance_score: number | undefined;
+    feedback: string;
+    feedback_time: number;
+}
+export interface FeedbackInfo {
+    who: AccountOrMark_Address;
+    acceptance_score?: number;
+    feedback?: string;
+}
+export interface CallDemand_Data {
+    object: WithPermissionObject;
+    present?: DemandPresent;
+    description?: string;
+    location?: string;
+    rewards?: {
+        op: "add" | "set";
+        objects: string[];
+    } | {
+        op: "remove";
+        objects: string[];
+    } | {
+        op: "clear";
+    };
+    feedback?: FeedbackInfo[];
+    guards?: {
+        op: "add" | "set";
+        guard: ServiceGuard[];
+    } | {
+        op: "remove";
+        guard: string[];
+    } | {
+        op: "clear";
+    };
+    owner_receive?: ReceivedObjectsOrRecently;
+    um?: string | null;
+}
+export declare class CallDemand extends CallBase {
+    data: CallDemand_Data;
+    object_address: string | undefined;
+    permission_address: string | undefined;
+    new_permission_description: string | undefined;
+    constructor(data: CallDemand_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 const MAX_REWARD_COUNT = 20;
+export declare const MAX_GUARD_COUNT = 20;
+export declare const MAX_FEEDBACK_COUNT = 20;
+export declare function create(tx: Transaction, demand: DemandObject): DemandAddress;
+export declare function present(tx: Transaction, demand: DemandObject, recommend: TxString, by_guard?: string, service?: ServiceObject, service_type?: string, passport?: PassportObject): void;
+export declare function newDemand(tx: Transaction, permission: PermissionObject, description: TxString, passport?: PassportObject): ObjectResult;
+export declare function description_set(tx: Transaction, demand: DemandObject, permission: PermissionObject, description: TxString, passport?: PassportObject): void;
+export declare function location_set(tx: Transaction, demand: DemandObject, permission: PermissionObject, location: TxString, passport?: PassportObject): void;
+export declare function guard_add(tx: Transaction, demand: DemandObject, permission: PermissionObject, guard: GuardObject, service_identifier: number | undefined | null, passport?: PassportObject): void;
+export declare function guard_remove(tx: Transaction, demand: DemandObject, permission: PermissionObject, guards: string[], passport?: PassportObject): void;
+export declare function guard_clear(tx: Transaction, demand: DemandObject, permission: PermissionObject, passport?: PassportObject): void;
+export declare function reward_add(tx: Transaction, demand: DemandObject, permission: PermissionObject, reward: string, reward_type: string, passport?: PassportObject): void;
+export declare function reward_remove(tx: Transaction, demand: DemandObject, permission: PermissionObject, rewards: string[], passport?: PassportObject): void;
+export declare function reward_clear(tx: Transaction, demand: DemandObject, permission: PermissionObject, passport?: PassportObject): void;
+export declare function feedback(tx: Transaction, demand: DemandObject, permission: PermissionObject, who: string, acceptance_score: number | undefined | null, feedback?: string, passport?: PassportObject): void;
+export declare function um_set(tx: Transaction, demand: DemandObject, permission: PermissionObject, um: string | null, passport?: PassportObject): void;