wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,2472 @@
+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,
+  toTxString,
+  isValidDescription,
+  MAX_DESCRIPTION_LENGTH,
+  isValidName,
+  isValidLongName,
+  isValidU16,
+  isValidU64,
+  PackageAddress,
+  MAX_LONG_NAME_LENGTH,
+  isValidArray,
+  IsValidArgType,
+  GetObjectExisted,
+  GetObject,
+  GetObjectDescription,
+  serviceFn,
+  MAX_NAME_LENGTH,
+  isValidHttpUrl
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { ObjectType } from "../query/object.js";
+import { owner_receive, parseObjectType, validObjects } from "../util.js";
+import { allocators } from "./allocation.js";
+import { CallBase, getCoinParam } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { GetManyAccountOrMark_Address } from "../local/index.js";
+import { LocalMark } from "../local/local.js";
+import {
+  agent_set,
+  order_required_info_update,
+  owner_change
+} from "./order.js";
+import { create as progressCreate } from "./progress.js";
+import { create as orderCreate } from "./order.js";
+import { create as permissionCreate } from "./permission.js";
+import { queryObjectsWithType } from "../query/util.js";
+import { query_received } from "../query/received.js";
+class CallService extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "permission_address");
+    __publicField(this, "new_permission_description");
+    __publicField(this, "parameter_type");
+    __publicField(this, "checkPublished", (op) => {
+      if (this.content && !this.content.bPublished) {
+        W_ERROR(
+          WErrors.Fail,
+          `Service object has not been published yet, so the operation (${op}) cannot proceed.`
+        );
+      }
+    });
+    __publicField(this, "checkNotPublished", (op) => {
+      if (this.content && this.content.bPublished) {
+        W_ERROR(
+          WErrors.Fail,
+          `Service object has been published and operation (${op}) cannot proceed. 
+                If further modifications are needed, you can 'clone' a new Service and then proceed with the operation.`
+        );
+      }
+    });
+    __publicField(this, "checkNotPaused", (op) => {
+      if (this.content && this.content.bPaused) {
+        W_ERROR(
+          WErrors.Fail,
+          `Service object has been paused and operation (${op}) cannot proceed.`
+        );
+      }
+    });
+    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.Service,
+        this.object_address
+      );
+      if (!this.content)
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallService_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      this.parameter_type = parseObjectType(
+        this.content.type_raw,
+        "service::Service"
+      );
+      if (!this.permission_address) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallService_Data.data.object.permission is empty"
+        );
+      }
+      if (!IsValidArgType(this.parameter_type)) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallService_Data.data.object.type_parameter is empty"
+        );
+      }
+    } else {
+      const n = GetObject(
+        this.data.object
+      );
+      this.permission_address = await GetObjectExisted(n?.permission);
+      this.new_permission_description = GetObjectDescription(
+        n?.permission
+      );
+      this.parameter_type = n?.type_parameter;
+      if (!IsValidArgType(this.parameter_type)) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallService_Data.data.object.type_parameter invalid"
+        );
+      }
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const guards = [];
+    const perms = [];
+    const add_guard = (guard) => {
+      if (!guards.includes(guard)) {
+        guards.push(guard);
+      }
+    };
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    if (this.permission_address && !this.object_address) {
+      add_perm(BuiltinPermissionIndex.SERVICE_NEW);
+    }
+    if (this.data?.order_new) {
+      if (!this.content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallService_Data.data.order_new fail because the Service ${JSON.stringify(this.data.object)} content not ready`
+        );
+      }
+      this.order_allowed();
+      if (this.content.buy_guard != null) {
+        add_guard(this.content.buy_guard);
+      }
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(BuiltinPermissionIndex.SERVICE_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.location != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_LOCATION);
+    }
+    if (this.permission_address && this.data?.repositories != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_REPOSITORY);
+    }
+    if (this.permission_address && this.data?.sales != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_SALES);
+    }
+    if (this.permission_address && this.data?.machine !== void 0) {
+      this.checkNotPublished("machine");
+      add_perm(BuiltinPermissionIndex.SERVICE_MACHINE);
+    }
+    if (this.permission_address && this.data?.discount != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_DISCOUNT);
+    }
+    if (this.permission_address && this.data?.arbitrations != null) {
+      this.checkNotPublished("arbitrations");
+      add_perm(BuiltinPermissionIndex.SERVICE_ARBITRATION);
+    }
+    if (this.permission_address && this.data?.customer_required != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_CUSTOMER_INFO_REQUIRED);
+    }
+    if (this.permission_address && this.data?.pause !== void 0) {
+      add_perm(BuiltinPermissionIndex.SERVICE_PAUSE);
+    }
+    if (this.permission_address && this.data?.publish) {
+      add_perm(BuiltinPermissionIndex.SERVICE_PUBLISH);
+    }
+    if (this.permission_address && this.data?.order_allocators !== void 0) {
+      this.checkNotPublished("order_allocators");
+      add_perm(BuiltinPermissionIndex.SERVICE_ORDER_ALLOCATOR);
+    }
+    if (this.permission_address && this.data?.compensation_fund_add != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_COMPENSATION_FUND_DEPOSIT);
+    }
+    if (this.permission_address && this.data?.compensation_locked_time_add !== void 0) {
+      add_perm(
+        BuiltinPermissionIndex.SERVICE_COMPENSATION_LOCKED_TIME_ADD
+      );
+    }
+    if (this.permission_address && this.data?.rewards != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_REWARD);
+    }
+    if (this.permission_address && this.data?.compensation_fund_receive != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_COMPENSATION_FUND_RECEIVE);
+    }
+    if (this.permission_address && this.data?.owner_receive != null) {
+      add_perm(BuiltinPermissionIndex.SERVICE_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data?.um !== void 0) {
+      add_perm(BuiltinPermissionIndex.SERVICE_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 = newPermission(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission && this.parameter_type) {
+        object = newService(
+          tx,
+          this.parameter_type,
+          permission,
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        "CallService_Data.data.object:" + this.object_address
+      );
+    }
+    let buyResult;
+    if (this.data?.order_new != null && this.content) {
+      this.order_allowed();
+      const n = this.data?.order_new;
+      n.buy.discount = await LocalMark.Instance().get_address(
+        this.data.order_new.buy.discount
+      );
+      buyResult = await buy(
+        env,
+        tx,
+        object,
+        this.parameter_type,
+        this.content.machine,
+        n.buy,
+        passport
+      );
+      if (!buyResult) {
+        W_ERROR(WErrors.Fail, "Buy failed, no order created");
+      }
+      if (n?.agents != null) {
+        agent_set(tx, {
+          order: buyResult.order,
+          agents: await GetManyAccountOrMark_Address(n.agents)
+        });
+      }
+      if (n?.order_required_info !== void 0) {
+        await order_required_info_update(
+          tx,
+          buyResult.order,
+          n.order_required_info
+        );
+      }
+      if (n?.transfer != null) {
+        await owner_change(tx, {
+          order: buyResult.order,
+          new_owner: n.transfer
+        });
+      }
+      if (n?.namedNewAllocation != null && buyResult?.allocation) {
+        await this.new_with_mark(
+          env,
+          tx,
+          ObjectType.Allocation,
+          buyResult?.allocation,
+          GetObject(n.namedNewAllocation)
+        );
+      }
+      if (buyResult?.progress) {
+        if (n?.namedNewProgress != null) {
+          await this.new_with_mark(
+            env,
+            tx,
+            ObjectType.Progress,
+            progressCreate(tx, buyResult?.progress),
+            GetObject(n.namedNewProgress)
+          );
+        } else {
+          progressCreate(tx, buyResult?.progress);
+        }
+      }
+      if (buyResult?.order) {
+        const addr = orderCreate(tx, buyResult?.order);
+        if (n?.namedNewOrder != null) {
+          await this.new_with_mark(
+            env,
+            tx,
+            ObjectType.Order,
+            addr,
+            GetObject(n.namedNewOrder)
+          );
+        }
+      }
+    }
+    if (this.data.description != null && !this.object_address) {
+      description_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.description,
+        passport
+      );
+    }
+    if (this.data.location != null) {
+      location_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.location,
+        passport
+      );
+    }
+    if (this.data.sales != null) {
+      switch (this.data.sales.op) {
+        case "add": {
+          sales_add(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            this.data.sales.sales,
+            passport
+          );
+          break;
+        }
+        case "set": {
+          sales_set(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            this.data.sales.sales,
+            passport
+          );
+          break;
+        }
+        case "remove": {
+          sales_remove(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            this.data.sales.sales_name,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          sales_clear(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            passport
+          );
+          break;
+        }
+      }
+    }
+    if (this.data.repositories != null) {
+      switch (this.data.repositories.op) {
+        case "add":
+        case "set": {
+          if (this.data.repositories.objects.length > MAX_REPOSITORY_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              "CallService_Data.data.repositories.objects:" + this.data.repositories.objects
+            );
+          }
+          if (this.data.repositories.op === "set") {
+            repository_clear(
+              tx,
+              object,
+              this.parameter_type,
+              permission,
+              passport
+            );
+          }
+          const r = await LocalMark.Instance().get_many_address_availables(
+            this.data.repositories.objects
+          );
+          r.forEach((repo) => {
+            repository_add(
+              tx,
+              object,
+              this.parameter_type,
+              permission,
+              repo,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.repositories.objects.length > MAX_REPOSITORY_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              "CallService_Data.data.repositories.objects:" + this.data.repositories.objects
+            );
+          }
+          const addrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.repositories.objects
+          );
+          repository_remove(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            addrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          repository_clear(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            passport
+          );
+          break;
+        }
+      }
+    }
+    if (this.data.rewards != null) {
+      switch (this.data.rewards.op) {
+        case "add":
+        case "set": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          if (this.data.rewards.op === "set") {
+            reward_clear(
+              tx,
+              object,
+              this.parameter_type,
+              permission,
+              passport
+            );
+          }
+          const rewards = await queryObjectsWithType(
+            env,
+            this.data.rewards.objects,
+            ObjectType.Reward,
+            "reward::Reward",
+            false
+          );
+          rewards.forEach((reward) => {
+            reward_add(
+              tx,
+              object,
+              this.parameter_type,
+              permission,
+              reward.object,
+              reward.type,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          const addrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.rewards.objects
+          );
+          reward_remove(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            addrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          reward_clear(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            passport
+          );
+          break;
+        }
+      }
+    }
+    if (this.data.arbitrations != null) {
+      switch (this.data.arbitrations.op) {
+        case "add":
+        case "set": {
+          if (this.data.arbitrations.objects.length > MAX_ARBITRATION_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `arbitrations count exceeds maximum limit ${MAX_ARBITRATION_COUNT}`
+            );
+          }
+          if (this.data.arbitrations.op === "set") {
+            arbitration_clear(
+              tx,
+              object,
+              this.parameter_type,
+              permission,
+              passport
+            );
+          }
+          const arbitrations = await queryObjectsWithType(
+            env,
+            this.data.arbitrations.objects,
+            ObjectType.Arbitration,
+            "arbitration::Arbitration",
+            false
+          );
+          arbitrations.forEach((arbitration) => {
+            arbitrations_add(
+              tx,
+              object,
+              this.parameter_type,
+              permission,
+              arbitration.object,
+              arbitration.type,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.arbitrations.objects.length > MAX_ARBITRATION_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `arbitrations count exceeds maximum limit ${MAX_ARBITRATION_COUNT}`
+            );
+          }
+          const addrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.arbitrations.objects
+          );
+          arbitrations_remove(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            addrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          arbitration_clear(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            passport
+          );
+          break;
+        }
+      }
+    }
+    if (this.data.discount != null) {
+      await discount(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.discount,
+        passport
+      );
+    }
+    if (this.data.discount_destroy != null) {
+      const r = await LocalMark.Instance().get_many_address_availables(
+        this.data.discount_destroy
+      );
+      discount_destroy(tx, r);
+    }
+    if (this.data.machine !== void 0) {
+      if (this.data.machine) {
+        const m = await LocalMark.Instance().get_address(
+          this.data.machine
+        );
+        if (m) {
+          this.data.machine = m;
+        } else {
+          W_ERROR(
+            WErrors.IsValidArgType,
+            `Machine not found ${this.data.machine}`
+          );
+        }
+      }
+      machine_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.machine,
+        passport
+      );
+    }
+    if (this.data.customer_required != null) {
+      customer_required_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.customer_required,
+        passport
+      );
+    }
+    if (this.data.order_allocators !== void 0) {
+      order_allocators_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.order_allocators ? await allocators(tx, this.data.order_allocators) : null,
+        passport
+      );
+    }
+    if (this.data.compensation_fund_add != null) {
+      compensation_fund_add(
+        env,
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.compensation_fund_add,
+        passport
+      );
+    }
+    if (this.data.compensation_locked_time_add !== void 0) {
+      compensation_lock_duration_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.compensation_locked_time_add,
+        passport
+      );
+    }
+    if (this.data.compensation_fund_receive != null && this.object_address) {
+      if (this.data.compensation_fund_receive === "recently") {
+        const received = await query_received({
+          object: this.object_address,
+          network: env.network,
+          no_cache: env.no_cache
+        });
+        if (Array.isArray(received)) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]"
+          );
+        } else {
+          this.data.compensation_fund_receive = received;
+        }
+      }
+      if (typeof this.data.compensation_fund_receive === "object" && "received" in this.data.compensation_fund_receive && this.data.compensation_fund_receive.received?.length > 0) {
+        if (this.data.compensation_fund_receive.token_type !== this.parameter_type) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `token_type ${this.data.compensation_fund_receive.token_type} is not equal to parameter_type ${this.parameter_type}`
+          );
+        }
+        for (const item of this.data.compensation_fund_receive.received) {
+          const [received_object, payment_object] = await Promise.all(
+            [
+              LocalMark.Instance().get_address(item.id),
+              LocalMark.Instance().get_address(item.payment)
+            ]
+          );
+          if (!received_object || !payment_object) {
+            W_ERROR(
+              WErrors.IsValidArgType,
+              `Compensation fund receive object ${item.id} or payment object ${item.payment} not found`
+            );
+          }
+          compensation_fund_receive(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            item.id,
+            item.payment,
+            passport
+          );
+        }
+      }
+    }
+    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,
+          network: env.network,
+          no_cache: env.no_cache
+        });
+      }
+      await owner_receive(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        this.parameter_type,
+        (name) => `${PackageAddress}::service::${name}`,
+        passport
+      );
+    }
+    if (this.data.um !== void 0) {
+      let um_address = null;
+      if (this.data.um) {
+        um_address = await LocalMark.Instance().get_address(this.data.um) || null;
+        if (!um_address) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallService_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        um_address,
+        passport
+      );
+    }
+    if (this.data.pause != null) {
+      pause(
+        tx,
+        object,
+        this.parameter_type,
+        permission,
+        this.data.pause,
+        passport
+      );
+    }
+    if (this.data.publish) {
+      publish(tx, object, this.parameter_type, permission, passport);
+    }
+    if (!this.permission_address) {
+      const p = GetObject(
+        this.data?.object
+      );
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Permission,
+        permissionCreate(tx, permission),
+        GetObject(p.permission)
+      );
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Service,
+        create(tx, object, this.parameter_type),
+        GetObject(this.data?.object)
+      );
+    }
+  }
+  order_allowed() {
+    if (this.content?.bPaused) {
+      W_ERROR(WErrors.InvalidParam, "Service is paused");
+      return false;
+    }
+    if (this.content?.bPublished !== true) {
+      W_ERROR(WErrors.InvalidParam, "Service is not published");
+      return false;
+    }
+    return true;
+  }
+}
+const MAX_SALE_COUNT = 50;
+const MAX_REPOSITORY_COUNT = 100;
+const MAX_ARBITRATION_COUNT = 20;
+const MAX_REWARD_COUNT = 20;
+const MAX_CUSTOMER_REQUIRED_INFO_COUNT = 10;
+const MAX_PUBKEY_LENGTH = 1024;
+const MAX_DISCOUNT_COUNT_ONCE = 1e3;
+const MAX_DISCOUNT_RECEIVER_ONCE = 1e3;
+const MAX_DISCOUNT_TOTAL_COUNT = 2e4;
+const MAX_REQUIRED_INFO_SIZE = 20;
+const DEFAULT_COMPENSATION_LOCK_DURATION = 2592e6;
+const DISCOUNT_TYPE_RATES = 0;
+const DISCOUNT_TYPE_MINUS = 1;
+const MAX_WIP_LENGTH = 1024;
+const MAX_WIP_HASH_LENGTH = 64;
+function sale(tx, sale2) {
+  if (typeof sale2.name === "string" && !isValidLongName(sale2.name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Name ${sale2.name} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (sale2.wip.length > MAX_WIP_LENGTH) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `WIP ${sale2.wip} exceeds maximum length ${MAX_WIP_LENGTH}`
+    );
+  }
+  if (!isValidHttpUrl(sale2.wip)) {
+    W_ERROR(
+      WErrors.IsValidHttpUrl,
+      `WIP ${sale2.wip} is not a valid HTTP/HTTPS URL`
+    );
+  }
+  if (sale2.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `WIP hash ${sale2.wip_hash} exceeds maximum length ${MAX_WIP_HASH_LENGTH}`
+    );
+  }
+  return tx.moveCall({
+    target: serviceFn("sale"),
+    arguments: [
+      toTxString(tx, sale2.name),
+      tx.pure.u64(sale2.price),
+      tx.pure.u64(sale2.stock),
+      tx.pure.bool(sale2.suspension),
+      toTxString(tx, sale2.wip),
+      toTxString(tx, sale2.wip_hash)
+    ]
+  });
+}
+function quote_item(tx, item) {
+  if (!isValidLongName(item.name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Quote item name ${item.name} is not valid`
+    );
+  }
+  if (!isValidU64(item.stock)) {
+    W_ERROR(
+      WErrors.IsValidU64,
+      `Quote item stock ${item.stock} is not valid`
+    );
+  }
+  if (item.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Quote item wip_hash ${item.wip_hash} exceeds maximum length ${MAX_WIP_HASH_LENGTH}`
+    );
+  }
+  return tx.moveCall({
+    target: serviceFn("quote_item"),
+    arguments: [
+      toTxString(tx, item.name),
+      tx.pure.u64(item.stock),
+      toTxString(tx, item.wip_hash)
+    ]
+  });
+}
+function discount_send(tx, discount2, recipient) {
+  if (discount2.length === 0) {
+    return;
+  }
+  validObjects([...discount2, recipient]);
+  if (discount2.length > MAX_DISCOUNT_COUNT_ONCE) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount count ${discount2.length} exceeds maximum limit ${MAX_DISCOUNT_COUNT_ONCE}`
+    );
+  }
+  if (discount2.length === 1) {
+    tx.moveCall({
+      target: serviceFn("discount_send_singleton"),
+      arguments: [
+        toTxObject(tx, discount2[0]),
+        tx.pure.address(recipient)
+      ]
+    });
+    return;
+  } else {
+    tx.moveCall({
+      target: serviceFn("discount_send"),
+      arguments: [
+        tx.makeMoveVec({
+          elements: discount2,
+          type: `${PackageAddress}::service::Discount`
+        }),
+        tx.pure.address(recipient)
+      ]
+    });
+  }
+}
+function discount_destroy(tx, discount2) {
+  validObjects([...discount2]);
+  discount2.forEach((item) => {
+    tx.moveCall({
+      target: serviceFn("discount_destroy"),
+      arguments: [toTxObject(tx, item)]
+    });
+  });
+}
+const buy = async (env, tx, service, service_type, machine, buy2, passport) => {
+  if (buy2.items.length === 0) {
+    return void 0;
+  }
+  validObjects([service, buy2.discount, machine, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Buy service type ${service_type} is not valid`
+    );
+  }
+  if (!isValidArray(buy2.items, (item) => {
+    if (!isValidLongName(item.name)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Buy item name ${item.name} is not valid`
+      );
+    }
+    if (!isValidU64(item.stock)) {
+      W_ERROR(
+        WErrors.IsValidU64,
+        `Buy item stock ${item.stock} is not valid`
+      );
+    }
+    return true;
+  })) {
+    W_ERROR(WErrors.InvalidParam, "Buy items is not valid");
+  }
+  if (typeof buy2.payment_remark === "string" && !isValidName(buy2.payment_remark)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Buy payment remark ${buy2.payment_remark} is not valid`
+    );
+  }
+  buy2.payment_remark = buy2.payment_remark || "";
+  if (buy2.payment_index != null && !isValidU64(buy2.payment_index)) {
+    W_ERROR(
+      WErrors.IsValidU64,
+      `Buy payment index ${buy2.payment_index} is not valid`
+    );
+  }
+  const coinParam = await getCoinParam(env, tx, buy2.total_pay, service_type);
+  buy2.discount = await LocalMark.Instance().get_address(buy2.discount);
+  let quote = void 0;
+  if (buy2.discount) {
+    quote = tx.moveCall({
+      target: serviceFn("quote_with_discount"),
+      arguments: [
+        toTxObject(tx, service),
+        tx.makeMoveVec({
+          elements: buy2.items.map((item) => quote_item(tx, item)),
+          type: `${PackageAddress}::service::QuoteItem`
+        }),
+        toTxObject(tx, buy2.discount)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    quote = tx.moveCall({
+      target: serviceFn("quote"),
+      arguments: [
+        toTxObject(tx, service),
+        tx.makeMoveVec({
+          elements: buy2.items.map((item) => quote_item(tx, item)),
+          type: `${PackageAddress}::service::QuoteItem`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+  let order;
+  if (passport) {
+    order = tx.moveCall({
+      target: serviceFn("buy_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, passport),
+        quote,
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    order = tx.moveCall({
+      target: serviceFn("buy"),
+      arguments: [
+        toTxObject(tx, service),
+        quote,
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+  const result = {
+    order
+  };
+  result.allocation = tx.moveCall({
+    target: serviceFn("order_allocation"),
+    arguments: [
+      toTxObject(tx, service),
+      toTxObject(tx, order),
+      coinParam,
+      tx.pure.string(buy2.payment_remark ?? ""),
+      tx.pure.u64(buy2.payment_index || 0),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ],
+    typeArguments: [service_type]
+  });
+  if (machine) {
+    result.progress = tx.moveCall({
+      target: serviceFn("order_progress"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, order),
+        toTxObject(tx, machine),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+  return result;
+};
+function newService(tx, service_type, permission, description, passport) {
+  validObjects([permission, passport]);
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `New service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: serviceFn("new_with_passport"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    return tx.moveCall({
+      target: serviceFn("new"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function description_set(tx, service, service_type, permission, description, passport) {
+  validObjects([service, permission, passport]);
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Description set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("description_set_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("description_set"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, description)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function um_set(tx, service, service_type, permission, um, passport) {
+  validObjects([service, permission]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Service type ${service_type} is not valid`
+    );
+  }
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: serviceFn(`um_set_with_passport`),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          passport,
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: serviceFn(`um_set`),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: serviceFn(`um_none_with_passport`),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: serviceFn(`um_none`),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  }
+}
+function location_set(tx, service, service_type, permission, location, passport) {
+  validObjects([service, permission, passport]);
+  if (typeof location === "string" && !isValidLongName(location)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Location ${location} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Location set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("location_set_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, location)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("location_set"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, location)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function create(tx, service, service_type) {
+  validObjects([service]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Create service type ${service_type} is not valid`
+    );
+  }
+  return tx.moveCall({
+    target: serviceFn("create"),
+    arguments: [toTxObject(tx, service)],
+    typeArguments: [service_type]
+  });
+}
+function sales_add(tx, service, service_type, permission, sales, passport) {
+  if (sales.length === 0) {
+    return;
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sales add service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("sales_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("sales_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sales_remove(tx, service, service_type, permission, sales_name, passport) {
+  if (sales_name.length === 0) {
+    return;
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sales remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("sales_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("string", sales_name)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("sales_remove"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.vector("string", sales_name)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sales_clear(tx, service, service_type, permission, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sales clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("sales_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("sales_clear"),
+      arguments: [toTxObject(tx, service), toTxObject(tx, permission)],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sales_set(tx, service, service_type, permission, sales, passport) {
+  if (sales.length === 0) {
+    return;
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sales set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("sales_set_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("sales_set"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function price_add(tx, service, service_type, permission, sale_name, price_add2, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Price add service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !isValidLongName(sale_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!isValidU64(price_add2)) {
+    W_ERROR(WErrors.IsValidU64, `Price add ${price_add2} is not valid`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("price_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, sale_name),
+        tx.pure.u64(price_add2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("price_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, sale_name),
+        tx.pure.u64(price_add2)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function price_reduce(tx, service, service_type, permission, sale_name, price_reduce2, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Price reduce service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !isValidLongName(sale_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!isValidU64(price_reduce2)) {
+    W_ERROR(
+      WErrors.IsValidU64,
+      `Price reduce ${price_reduce2} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("price_reduce_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, sale_name),
+        tx.pure.u64(price_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("price_reduce"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, sale_name),
+        tx.pure.u64(price_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function stock_add(tx, service, service_type, permission, sale_name, stock_add2, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Stock add service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !isValidLongName(sale_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!isValidU64(stock_add2)) {
+    W_ERROR(WErrors.IsValidU64, `Stock add ${stock_add2} is not valid`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("stock_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, sale_name),
+        tx.pure.u64(stock_add2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("stock_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, sale_name),
+        tx.pure.u64(stock_add2)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function stock_reduce(tx, service, service_type, permission, sale_name, stock_reduce2, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Stock reduce service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !isValidLongName(sale_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!isValidU64(stock_reduce2)) {
+    W_ERROR(
+      WErrors.IsValidU64,
+      `Stock reduce ${stock_reduce2} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("stock_reduce_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, sale_name),
+        tx.pure.u64(stock_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("stock_reduce"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, sale_name),
+        tx.pure.u64(stock_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sale_suspension(tx, service, service_type, permission, sale_name, suspension, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sale suspension service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !isValidLongName(sale_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("sale_suspension_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, sale_name),
+        tx.pure.bool(suspension)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("sale_suspension"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxString(tx, sale_name),
+        tx.pure.bool(suspension)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function repository_add(tx, service, service_type, permission, repository, passport) {
+  validObjects([service, permission, repository, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Repository add service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("repository_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("repository_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function repository_remove(tx, service, service_type, permission, repositories, passport) {
+  if (repositories.length === 0) {
+    return;
+  }
+  validObjects([service, permission, passport, ...repositories]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Repository remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("repository_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", repositories),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("repository_remove"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", repositories),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function repository_clear(tx, service, service_type, permission, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Repository clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("repository_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("repository_clear"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function buy_guard_set(tx, service, service_type, permission, guard, passport) {
+  validObjects([service, permission, guard, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Buy guard set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    if (guard) {
+      tx.moveCall({
+        target: serviceFn("buy_guard_set_with_passport"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          toTxObject(tx, guard),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: serviceFn("buy_guard_none_with_passport"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  } else {
+    if (guard) {
+      tx.moveCall({
+        target: serviceFn("buy_guard_set"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, guard),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: serviceFn("buy_guard_none"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  }
+}
+function machine_set(tx, service, service_type, permission, machine, passport) {
+  validObjects([service, permission, machine, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Machine set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    if (machine) {
+      tx.moveCall({
+        target: serviceFn("machine_set_with_passport"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          toTxObject(tx, machine),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: serviceFn("machine_none_with_passport"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  } else {
+    if (machine) {
+      tx.moveCall({
+        target: serviceFn("machine_set"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          toTxObject(tx, machine),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: serviceFn("machine_set_none"),
+        arguments: [
+          toTxObject(tx, service),
+          toTxObject(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  }
+}
+function publish(tx, service, service_type, permission, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Publish service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("publish_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("publish"),
+      arguments: [toTxObject(tx, service), toTxObject(tx, permission)],
+      typeArguments: [service_type]
+    });
+  }
+}
+function pause(tx, service, service_type, permission, bPaused, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Pause service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("pause_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.bool(bPaused),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("pause"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.bool(bPaused),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function customer_required_set(tx, service, service_type, permission, required_info, passport) {
+  if (required_info.length > MAX_REQUIRED_INFO_SIZE) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Customer required set size ${required_info.length} is exceed maximum size ${MAX_REQUIRED_INFO_SIZE}`
+    );
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Customer required set service type ${service_type} is not valid`
+    );
+  }
+  required_info.forEach((item) => {
+    if (!isValidName(item)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Customer required info ${item} is exceed maximum length ${MAX_NAME_LENGTH} or start with "0x"`
+      );
+    }
+  });
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("custom_required_info_set_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("string", required_info)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("custom_required_info_set"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.vector("string", required_info)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function arbitrations_add(tx, service, service_type, permission, arbitration, arbitration_type, passport) {
+  validObjects([service, permission, arbitration, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Arbitrations add service type ${service_type} is not valid`
+    );
+  }
+  if (!IsValidArgType(arbitration_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Arbitrations add arbitration type ${arbitration_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("arbitration_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, arbitration),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("arbitrations_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, arbitration),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type, arbitration_type]
+    });
+  }
+}
+function arbitrations_remove(tx, service, service_type, permission, arbitrations, passport) {
+  if (arbitrations.length === 0) {
+    return;
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Arbitrations remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("arbitration_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", arbitrations),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("arbitration_remove"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", arbitrations),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function arbitration_clear(tx, service, service_type, permission, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Arbitrations clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("arbitration_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("arbitration_clear"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+async function compensation_fund_add(env, tx, service, service_type, permission, coin, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation fund add service type ${service_type} is not valid`
+    );
+  }
+  const coinParam = await getCoinParam(env, tx, coin, service_type);
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("compensation_fund_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        coinParam
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("compensation_fund_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        coinParam
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function compensation_lock_duration_set(tx, service, service_type, permission, duration_ms, passport) {
+  if (!isValidU64(duration_ms) || duration_ms === 0) {
+    return;
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation lock duration set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("compensation_lock_duration_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.u64(duration_ms)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("compensation_lock_duration_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.u64(duration_ms)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function order_allocators_set(tx, service, service_type, permission, allocators2, passport) {
+  validObjects([service, permission, allocators2, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Order allocators set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("order_allocators_set_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.option({
+          type: `${PackageAddress}::allocation::Allocators`,
+          value: allocators2 ?? null
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("order_allocators_set"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.object.option({
+          type: `${PackageAddress}::allocation::Allocators`,
+          value: allocators2 ?? null
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function reward_add(tx, service, service_type, permission, reward, reward_type, passport) {
+  validObjects([service, permission, reward, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Rewards add service type ${service_type} is not valid`
+    );
+  }
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Rewards add reward type ${reward_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("reward_add_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, reward),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type, reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("reward_add"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, reward),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type, reward_type]
+    });
+  }
+}
+function reward_remove(tx, service, service_type, permission, rewards, passport) {
+  if (rewards.length === 0) {
+    return;
+  }
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Rewards remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("reward_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("reward_remove"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function reward_clear(tx, service, service_type, permission, passport) {
+  validObjects([service, permission, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Rewards clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("reward_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("reward_clear"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function compensation_fund_receive(tx, service, service_type, permission, received_object, payment, passport) {
+  if (!payment) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation fund receive payment is required`
+    );
+  }
+  validObjects([service, permission, received_object, payment, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation fund receive service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("compensation_fund_receive_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, received_object),
+        toTxObject(tx, payment)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("compensation_fund_receive"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, received_object),
+        toTxObject(tx, payment)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function compensation_fund_withdraw(tx, service, service_type, payment_info, receipt, permission, passport) {
+  validObjects([service, permission, receipt, payment_info, passport]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation fund withdraw service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("compensation_fund_withdraw_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.address(receipt),
+        toTxObject(tx, payment_info),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("compensation_fund_withdraw"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.address(receipt),
+        toTxObject(tx, payment_info),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+async function discount(tx, service, service_type, permission, discount2, passport) {
+  let recipient = [];
+  if (Array.isArray(discount2.recipient)) {
+    recipient = discount2.recipient;
+  } else {
+    recipient = await GetManyAccountOrMark_Address(discount2.recipient);
+  }
+  if (recipient.length === 0 || discount2.count === 0) {
+    return;
+  }
+  if (recipient.length > MAX_DISCOUNT_RECEIVER_ONCE) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount recipient length ${recipient.length} is exceed max ${MAX_DISCOUNT_RECEIVER_ONCE}`
+    );
+  }
+  if (!isValidName(discount2.name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount name ${discount2.name} is not valid`
+    );
+  }
+  if (!isValidU16(discount2.count) || discount2.count > MAX_DISCOUNT_COUNT_ONCE) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount count ${discount2.count} is exceed max ${MAX_DISCOUNT_COUNT_ONCE}`
+    );
+  }
+  if (recipient.length * discount2.count > MAX_DISCOUNT_TOTAL_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount total count ${recipient.length * discount2.count} is exceed max ${MAX_DISCOUNT_TOTAL_COUNT}`
+    );
+  }
+  if (discount2.benchmark != null && !isValidU64(discount2.benchmark)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount benchmark ${discount2.benchmark} is not valid`
+    );
+  }
+  const start = discount2.time_ms_start ?? Date.now();
+  if (discount2.time_ms_end < start) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount time_ms_end ${discount2.time_ms_end} is not valid`
+    );
+  }
+  if (discount2.discount_value != null && !isValidU64(discount2.discount_value)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount discount_value ${discount2.discount_value} is not valid`
+    );
+  }
+  validObjects([service, permission, passport, ...recipient]);
+  if (!IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Discount service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: serviceFn("discount_with_passport"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.string(discount2.name),
+        tx.pure.u8(discount2.discount_type),
+        tx.pure.u64(discount2.discount_value),
+        tx.pure.option("u64", discount2.benchmark ?? null),
+        tx.pure.bool(discount2.transferable),
+        tx.pure.option("u64", discount2.time_ms_start ?? null),
+        tx.pure.u64(discount2.time_ms_end),
+        tx.pure.u16(discount2.count),
+        tx.pure.vector("address", recipient),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: serviceFn("discount"),
+      arguments: [
+        toTxObject(tx, service),
+        toTxObject(tx, permission),
+        tx.pure.string(discount2.name),
+        tx.pure.u8(discount2.discount_type),
+        tx.pure.u64(discount2.discount_value),
+        tx.pure.option("u64", discount2.benchmark ?? null),
+        tx.pure.bool(discount2.transferable),
+        tx.pure.option("u64", discount2.time_ms_start ?? null),
+        tx.pure.u64(discount2.time_ms_end),
+        tx.pure.u16(discount2.count),
+        tx.pure.vector("address", recipient),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+export {
+  CallService,
+  DEFAULT_COMPENSATION_LOCK_DURATION,
+  DISCOUNT_TYPE_MINUS,
+  DISCOUNT_TYPE_RATES,
+  MAX_ARBITRATION_COUNT,
+  MAX_CUSTOMER_REQUIRED_INFO_COUNT,
+  MAX_DISCOUNT_COUNT_ONCE,
+  MAX_DISCOUNT_RECEIVER_ONCE,
+  MAX_DISCOUNT_TOTAL_COUNT,
+  MAX_PUBKEY_LENGTH,
+  MAX_REPOSITORY_COUNT,
+  MAX_REQUIRED_INFO_SIZE,
+  MAX_REWARD_COUNT,
+  MAX_SALE_COUNT,
+  arbitration_clear,
+  arbitrations_add,
+  arbitrations_remove,
+  buy,
+  buy_guard_set,
+  compensation_fund_add,
+  compensation_fund_receive,
+  compensation_fund_withdraw,
+  compensation_lock_duration_set,
+  create,
+  customer_required_set,
+  description_set,
+  discount,
+  discount_destroy,
+  discount_send,
+  location_set,
+  machine_set,
+  newService,
+  order_allocators_set,
+  pause,
+  price_add,
+  price_reduce,
+  publish,
+  repository_add,
+  repository_clear,
+  repository_remove,
+  reward_add,
+  reward_clear,
+  reward_remove,
+  sale_suspension,
+  sales_add,
+  sales_clear,
+  sales_remove,
+  sales_set,
+  stock_add,
+  stock_reduce,
+  um_set
+};