wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,872 @@
+"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 demand_exports = {};
+__export(demand_exports, {
+  CallDemand: () => CallDemand,
+  MAX_FEEDBACK_COUNT: () => MAX_FEEDBACK_COUNT,
+  MAX_GUARD_COUNT: () => MAX_GUARD_COUNT,
+  MAX_REWARD_COUNT: () => MAX_REWARD_COUNT,
+  create: () => create,
+  description_set: () => description_set,
+  feedback: () => feedback,
+  guard_add: () => guard_add,
+  guard_clear: () => guard_clear,
+  guard_remove: () => guard_remove,
+  location_set: () => location_set,
+  newDemand: () => newDemand,
+  present: () => present,
+  reward_add: () => reward_add,
+  reward_clear: () => reward_clear,
+  reward_remove: () => reward_remove,
+  um_set: () => um_set
+});
+module.exports = __toCommonJS(demand_exports);
+var import_sui_types = require("../../utils/sui-types.js");
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_local = require("../local/index.js");
+var import_local2 = require("../local/local.js");
+var import_object = require("../query/object.js");
+var import_received = require("../query/received.js");
+var import_util = require("../query/util.js");
+var import_util2 = require("../util.js");
+var import_base = require("./base.js");
+var import_permission = require("./permission.js");
+var import_permission2 = require("./permission.js");
+class CallDemand 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.Demand,
+        this.object_address
+      );
+      if (!this.content)
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallDemand_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+    } 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 guards = [];
+    const perms = [];
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    if (this.permission_address && !this.object_address) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_NEW);
+    }
+    if (this.data.present?.by_guard != null) {
+      if (!this.content) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallDemand_Data.data.present.by_guard fail because the Demand content not ready"
+        );
+      }
+      this.data.present.by_guard = await import_local2.LocalMark.Instance().get_address(
+        this.data.present.by_guard
+      );
+      if (this.data.present.by_guard) {
+        const f = this.content?.guards.find(
+          (v) => v.guard === this.data.present.by_guard
+        );
+        if (f) {
+          guards.push(this.data.present.by_guard);
+        } else {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `guard ${this.data.present.by_guard} not found in guards: ${this.content.guards.map((v) => v.guard)}`
+          );
+        }
+      } else if (this.content && this.content.guards.length > 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `guard is required when present guards ${this.content.guards.map((v) => v.guard)} is not empty`
+        );
+      }
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.location != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_LOCATION);
+    }
+    if (this.permission_address && this.data?.rewards != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_REWARD);
+    }
+    if (this.permission_address && this.data?.feedback != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_FEEDBACK);
+    }
+    if (this.permission_address && this.data?.guards != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_GUARD);
+    }
+    if (this.permission_address && this.data?.owner_receive != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data.um !== void 0) {
+      add_perm(import_permission.BuiltinPermissionIndex.DEMAND_UM);
+    }
+    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;
+    if (!this.object_address) {
+      if (!permission) {
+        permission = (0, import_permission.newPermission)(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission) {
+        object = newDemand(
+          tx,
+          (0, import_common.toTxObject)(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        "CallDemand_Data.data.object:" + this.object_address
+      );
+    }
+    if (this.data.present != null && this.content) {
+      if (this.data.present.by_guard) {
+        const f = this.content.guards.find(
+          (v) => v.guard === this.data.present.by_guard
+        );
+        if (f && f.service_identifier != null) {
+          const sub = submission?.find((v) => v.guard === this.data.present.by_guard)?.submission?.find(
+            (v) => Number(v.identifier) === Number(f.service_identifier)
+          );
+          const subValueType = sub ? (0, import_common.parseValueType)(sub.value_type) : void 0;
+          if (sub && subValueType === import_common.ValueType.Address && sub.value && (0, import_sui_types.isValidWowAddress)(sub.value)) {
+            this.data.present.service = void 0;
+          } else {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `submission ${f.service_identifier} invalid in the guard ${this.data.present.by_guard}`
+            );
+          }
+        }
+      }
+      let serviceObject = void 0;
+      let serviceType = void 0;
+      if (typeof this.data.present.service === "string" && this.data.present.service) {
+        const serviceResult = await (0, import_util.queryObjectWithType)(
+          env,
+          this.data.present.service,
+          import_object.ObjectType.Service,
+          "service::Service"
+        );
+        if (serviceResult) {
+          serviceObject = serviceResult.object;
+          serviceType = serviceResult.type;
+        } else {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `service ${this.data.present.service} not found`
+          );
+        }
+      }
+      present(
+        tx,
+        object,
+        this.data.present.recommend,
+        this.data.present.by_guard,
+        serviceObject,
+        serviceType,
+        passport
+      );
+    }
+    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?.rewards != null) {
+      switch (this.data?.rewards.op) {
+        case "set":
+        case "add": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          if (this.data.rewards.op === "set") {
+            reward_clear(tx, object, permission, passport);
+          }
+          let rewardResults = [];
+          if (this.data.rewards.objects.length > 0) {
+            rewardResults = await (0, import_util.queryObjectsWithType)(
+              env,
+              this.data.rewards.objects,
+              import_object.ObjectType.Reward,
+              "reward::Reward"
+            );
+          }
+          rewardResults.forEach((rewardResult) => {
+            reward_add(
+              tx,
+              object,
+              permission,
+              rewardResult.object,
+              rewardResult.type,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          const rewardAddrs = await import_local2.LocalMark.Instance().get_many_address_availables(
+            this.data.rewards.objects
+          );
+          reward_remove(
+            tx,
+            object,
+            permission,
+            rewardAddrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          reward_clear(tx, object, permission, passport);
+          break;
+        }
+      }
+    }
+    if (this.data?.feedback != null) {
+      if (this.data.feedback.length > MAX_FEEDBACK_COUNT) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `feedback count exceeds maximum limit ${MAX_FEEDBACK_COUNT}`
+        );
+      }
+      for (const v of this.data.feedback) {
+        const who = await (0, import_local.GetAccountOrMark_Address)(v.who);
+        if (who) {
+          feedback(
+            tx,
+            object,
+            permission,
+            who,
+            v.acceptance_score,
+            v.feedback,
+            passport
+          );
+        }
+      }
+    }
+    if (this.data?.guards != null) {
+      switch (this.data?.guards.op) {
+        case "set":
+        case "add": {
+          if (this.data.guards.guard.length > MAX_GUARD_COUNT) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `guards count exceeds maximum limit ${MAX_GUARD_COUNT}`
+            );
+          }
+          if (this.data.guards.op === "set") {
+            guard_clear(tx, object, permission, passport);
+          }
+          for (const guard of this.data.guards.guard) {
+            const addr = await import_local2.LocalMark.Instance().get_address(
+              guard.guard
+            );
+            if (addr) {
+              guard_add(
+                tx,
+                object,
+                permission,
+                addr,
+                guard.service_identifier,
+                passport
+              );
+            }
+          }
+          break;
+        }
+        case "remove": {
+          if (this.data.guards.guard.length > MAX_GUARD_COUNT) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `guards count exceeds maximum limit ${MAX_GUARD_COUNT}`
+            );
+          }
+          const guardAddrs = await import_local2.LocalMark.Instance().get_many_address_availables(
+            this.data.guards.guard
+          );
+          guard_remove(
+            tx,
+            object,
+            permission,
+            guardAddrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          guard_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_util2.owner_receive)(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        void 0,
+        (name) => `${import_common.PackageAddress}::demand::${name}`,
+        passport
+      );
+    }
+    if (this.data.um !== void 0) {
+      let um_address = null;
+      if (this.data.um) {
+        um_address = await import_local2.LocalMark.Instance().get_address(this.data.um) || null;
+        if (!um_address) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            "CallDemand_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(tx, object, permission, um_address, 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.Demand,
+        create(tx, object),
+        (0, import_common.GetObject)(this.data?.object)
+      );
+    }
+  }
+}
+const MAX_REWARD_COUNT = 20;
+const MAX_GUARD_COUNT = 20;
+const MAX_FEEDBACK_COUNT = 20;
+function create(tx, demand) {
+  (0, import_util2.validObjects)([demand]);
+  return tx.moveCall({
+    target: (0, import_common.demandFn)("create"),
+    arguments: [(0, import_common.toTxObject)(tx, demand)]
+  });
+}
+function present(tx, demand, recommend, by_guard, service, service_type, passport) {
+  (0, import_util2.validObjects)([demand, service, by_guard, passport]);
+  recommend = recommend || "";
+  if (typeof recommend === "string" && !(0, import_common.isValidDescription)(recommend)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Recommend exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (service && !(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidArgType,
+      `Service type ${service_type} is not valid`
+    );
+  }
+  if (by_guard) {
+    if (!passport) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Passport is required when by_guard ${by_guard} is present`
+      );
+    }
+    if (service) {
+      tx.moveCall({
+        target: (0, import_common.demandFn)("present_service_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, demand),
+          (0, import_common.toTxObject)(tx, by_guard),
+          (0, import_common.toTxObject)(tx, passport),
+          (0, import_common.toTxString)(tx, recommend),
+          (0, import_common.toTxObject)(tx, service),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.demandFn)("present_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, demand),
+          (0, import_common.toTxObject)(tx, by_guard),
+          (0, import_common.toTxObject)(tx, passport),
+          (0, import_common.toTxString)(tx, recommend),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else if (service) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("present_service"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxString)(tx, recommend),
+        (0, import_common.toTxObject)(tx, service),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("present"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxString)(tx, recommend),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function newDemand(tx, permission, description, passport) {
+  (0, import_util2.validObjects)([permission, passport]);
+  if (typeof description === "string" && !(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.demandFn)("new_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: (0, import_common.demandFn)("new"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function description_set(tx, demand, permission, description, passport) {
+  (0, import_util2.validObjects)([demand, permission, passport]);
+  if (typeof description === "string" && !(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description ${description} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("description_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, description)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("description_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, description)
+      ]
+    });
+  }
+}
+function location_set(tx, demand, permission, location, passport) {
+  (0, import_util2.validObjects)([demand, permission, passport]);
+  if (typeof location === "string" && !(0, import_common.isValidLongName)(location)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Location ${location} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("location_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, location)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("location_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, location)
+      ]
+    });
+  }
+}
+function guard_add(tx, demand, permission, guard, service_identifier, passport) {
+  (0, import_util2.validObjects)([demand, permission, guard, passport]);
+  if (typeof service_identifier === "number") {
+    if (!(0, import_common.isValidU8)(service_identifier)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.IsValidU8,
+        `Service identifier ${service_identifier} is invalid`
+      );
+    }
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("guard_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxObject)(tx, guard),
+        tx.pure.option("u8", service_identifier ?? null),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("guard_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, guard),
+        tx.pure.option("u8", service_identifier ?? null),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function guard_remove(tx, demand, permission, guards, passport) {
+  if (guards.length === 0) {
+    return;
+  }
+  (0, import_util2.validObjects)([demand, permission, passport, ...guards]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("guard_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", guards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("guard_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", guards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function guard_clear(tx, demand, permission, passport) {
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("guard_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("guard_clear"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function reward_add(tx, demand, permission, reward, reward_type, passport) {
+  (0, import_util2.validObjects)([demand, permission, passport, reward]);
+  if (!(0, import_common.IsValidArgType)(reward_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidArgType,
+      `Reward type ${reward_type} is invalid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("reward_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxObject)(tx, reward),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("reward_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, reward),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function reward_remove(tx, demand, permission, rewards, passport) {
+  if (rewards.length === 0) {
+    return;
+  }
+  (0, import_util2.validObjects)([demand, permission, passport, ...rewards]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("reward_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("reward_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function reward_clear(tx, demand, permission, passport) {
+  (0, import_util2.validObjects)([demand, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("reward_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("reward_clear"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function feedback(tx, demand, permission, who, acceptance_score, feedback2, passport) {
+  (0, import_util2.validObjects)([demand, permission, who, passport]);
+  if (typeof feedback2 === "string" && !(0, import_common.isValidDescription)(feedback2)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Feedback exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (typeof acceptance_score === "number" && !(0, import_common.isValidU8)(acceptance_score)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU8,
+      `Acceptance score ${acceptance_score} is invalid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("feedback_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.address(who),
+        tx.pure.option("u8", acceptance_score ?? null),
+        tx.pure.string(feedback2 ?? ""),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.demandFn)("feedback"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, demand),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.address(who),
+        tx.pure.option("u8", acceptance_score ?? null),
+        tx.pure.string(feedback2 ?? ""),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function um_set(tx, demand, permission, um, passport) {
+  (0, import_util2.validObjects)([demand, permission]);
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: (0, import_common.demandFn)(`um_set_with_passport`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, demand),
+          (0, import_common.toTxObject)(tx, permission),
+          passport,
+          (0, import_common.toTxObject)(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.demandFn)(`um_set`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, demand),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: (0, import_common.demandFn)(`um_none_with_passport`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, demand),
+          (0, import_common.toTxObject)(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.demandFn)(`um_none`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, demand),
+          (0, import_common.toTxObject)(tx, permission),
+          tx.object.mutRegistrar()
+        ]
+      });
+    }
+  }
+}