wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,474 @@
+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 {
+  toTxObject,
+  isValidName,
+  isValidDescription,
+  PackageAddress,
+  MAX_NAME_LENGTH,
+  isValidArray,
+  GetObjectExisted,
+  GetObject,
+  GetObjectDescription,
+  contactFn,
+  MAX_DESCRIPTION_LENGTH,
+  isValidLongName,
+  MAX_LONG_NAME_LENGTH
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { ObjectType } from "../query/object.js";
+import { CallBase } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { create as permission_create } from "./permission.js";
+import { owner_receive, validObjects } from "../util.js";
+import { Account } from "../local/index.js";
+import { query_received } from "../query/received.js";
+import { isValidWowAddress } from "../../utils/sui-types.js";
+const MAX_IM_COUNT = 200;
+class CallContact extends 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 GetObjectExisted(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        ObjectType.Machine,
+        this.object_address
+      );
+      if (!this.content)
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallContact_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      if (!this.permission_address) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallContact_Data.data.object.permission is empty"
+        );
+      }
+    } else {
+      const n = GetObject(this.data.object);
+      this.permission_address = await GetObjectExisted(n?.permission);
+      this.new_permission_description = 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)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallContact_Data.data.my_status: your account not in im list"
+        );
+      }
+    }
+    if (this.permission_address && !this.object_address) {
+      add_perm(BuiltinPermissionIndex.MESSNGER_NEW);
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(BuiltinPermissionIndex.MESSNGER_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.location !== void 0) {
+      add_perm(BuiltinPermissionIndex.MESSNGER_LOCATION);
+    }
+    if (this.permission_address && this.data.ims != null) {
+      add_perm(BuiltinPermissionIndex.MESSNGER_IM);
+    }
+    if (this.permission_address && this.data?.owner_receive) {
+      add_perm(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 = newPermission(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission) {
+        object = newContact(
+          tx,
+          toTxObject(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      W_ERROR(
+        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)) {
+            W_ERROR(
+              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 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) {
+            W_ERROR(
+              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 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) {
+            W_ERROR(
+              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 query_received({
+          object: this.object_address,
+          all_type: true,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      }
+      await owner_receive(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        void 0,
+        (name) => `${PackageAddress}::contact::${name}`,
+        passport
+      );
+    }
+    if (!this.permission_address) {
+      const p = GetObject(this.data?.object);
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Permission,
+        permission_create(tx, permission),
+        GetObject(p.permission)
+      );
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Contact,
+        create(tx, object),
+        GetObject(this.data?.object)
+      );
+    }
+  }
+}
+function create(tx, contact) {
+  return tx.moveCall({
+    target: contactFn("create"),
+    arguments: [toTxObject(tx, contact)]
+  });
+}
+function change_status(tx, contact, status) {
+  if (!isValidName(status)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Status name(${status}) exceeds the length limit(${MAX_NAME_LENGTH})`
+    );
+  }
+  return tx.moveCall({
+    target: contactFn("change_status"),
+    arguments: [toTxObject(tx, contact), tx.pure.string(status)]
+  });
+}
+function newContact(tx, permission, description, passport) {
+  validObjects([permission]);
+  if (!isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length(${MAX_DESCRIPTION_LENGTH})`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: contactFn("new_with_passport"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.string(description),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: contactFn("new"),
+      arguments: [
+        toTxObject(tx, permission),
+        tx.pure.string(description),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function description_set(tx, contact, permission, description, passport) {
+  validObjects([contact, permission]);
+  if (!isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length(${MAX_DESCRIPTION_LENGTH})`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: contactFn("description_set_with_passport"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.string(description)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: contactFn("description_set"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        tx.pure.string(description)
+      ]
+    });
+  }
+}
+function location_set(tx, contact, permission, location, passport) {
+  validObjects([contact, permission]);
+  if (!isValidLongName(location)) {
+    W_ERROR(
+      WErrors.IsValidLocation,
+      `Location exceeds maximum length(${MAX_LONG_NAME_LENGTH})`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: contactFn("location_set_with_passport"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.string(location)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: contactFn("location_set"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        tx.pure.string(location)
+      ]
+    });
+  }
+}
+function im_add(tx, contact, permission, im, description, passport) {
+  validObjects([contact, permission]);
+  if (!isValidWowAddress(im)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `IM address(${im}) is not a valid address`
+    );
+  }
+  if (description && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length(${MAX_DESCRIPTION_LENGTH})`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: contactFn("im_add_with_passport"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.address(im),
+        tx.pure.option("string", description),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: contactFn("im_add"),
+      arguments: [
+        toTxObject(tx, contact),
+        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;
+  }
+  validObjects([contact, permission]);
+  isValidArray(im, (item) => {
+    if (!isValidWowAddress(item)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `IM address(${item}) is not a valid address`
+      );
+      return false;
+    }
+    return true;
+  });
+  if (passport) {
+    tx.moveCall({
+      target: contactFn("im_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", im)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: contactFn("im_remove"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", im)
+      ]
+    });
+  }
+}
+function im_clear(tx, contact, permission, passport) {
+  validObjects([contact, permission]);
+  if (passport) {
+    tx.moveCall({
+      target: contactFn("im_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, contact),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: contactFn("im_clear"),
+      arguments: [toTxObject(tx, contact), toTxObject(tx, permission)]
+    });
+  }
+}
+export {
+  CallContact,
+  MAX_IM_COUNT,
+  change_status,
+  create,
+  description_set,
+  im_add,
+  im_clear,
+  im_remove,
+  location_set,
+  newContact
+};

package/dist/esm/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;