wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,2468 @@
+"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 service_exports = {};
+__export(service_exports, {
+  CallService: () => CallService,
+  DEFAULT_COMPENSATION_LOCK_DURATION: () => DEFAULT_COMPENSATION_LOCK_DURATION,
+  DISCOUNT_TYPE_MINUS: () => DISCOUNT_TYPE_MINUS,
+  DISCOUNT_TYPE_RATES: () => DISCOUNT_TYPE_RATES,
+  MAX_ARBITRATION_COUNT: () => MAX_ARBITRATION_COUNT,
+  MAX_CUSTOMER_REQUIRED_INFO_COUNT: () => MAX_CUSTOMER_REQUIRED_INFO_COUNT,
+  MAX_DISCOUNT_COUNT_ONCE: () => MAX_DISCOUNT_COUNT_ONCE,
+  MAX_DISCOUNT_RECEIVER_ONCE: () => MAX_DISCOUNT_RECEIVER_ONCE,
+  MAX_DISCOUNT_TOTAL_COUNT: () => MAX_DISCOUNT_TOTAL_COUNT,
+  MAX_PUBKEY_LENGTH: () => MAX_PUBKEY_LENGTH,
+  MAX_REPOSITORY_COUNT: () => MAX_REPOSITORY_COUNT,
+  MAX_REQUIRED_INFO_SIZE: () => MAX_REQUIRED_INFO_SIZE,
+  MAX_REWARD_COUNT: () => MAX_REWARD_COUNT,
+  MAX_SALE_COUNT: () => MAX_SALE_COUNT,
+  arbitration_clear: () => arbitration_clear,
+  arbitrations_add: () => arbitrations_add,
+  arbitrations_remove: () => arbitrations_remove,
+  buy: () => buy,
+  buy_guard_set: () => buy_guard_set,
+  compensation_fund_add: () => compensation_fund_add,
+  compensation_fund_receive: () => compensation_fund_receive,
+  compensation_fund_withdraw: () => compensation_fund_withdraw,
+  compensation_lock_duration_set: () => compensation_lock_duration_set,
+  create: () => create,
+  customer_required_set: () => customer_required_set,
+  description_set: () => description_set,
+  discount: () => discount,
+  discount_destroy: () => discount_destroy,
+  discount_send: () => discount_send,
+  location_set: () => location_set,
+  machine_set: () => machine_set,
+  newService: () => newService,
+  order_allocators_set: () => order_allocators_set,
+  pause: () => pause,
+  price_add: () => price_add,
+  price_reduce: () => price_reduce,
+  publish: () => publish,
+  repository_add: () => repository_add,
+  repository_clear: () => repository_clear,
+  repository_remove: () => repository_remove,
+  reward_add: () => reward_add,
+  reward_clear: () => reward_clear,
+  reward_remove: () => reward_remove,
+  sale_suspension: () => sale_suspension,
+  sales_add: () => sales_add,
+  sales_clear: () => sales_clear,
+  sales_remove: () => sales_remove,
+  sales_set: () => sales_set,
+  stock_add: () => stock_add,
+  stock_reduce: () => stock_reduce,
+  um_set: () => um_set
+});
+module.exports = __toCommonJS(service_exports);
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_object = require("../query/object.js");
+var import_util = require("../util.js");
+var import_allocation = require("./allocation.js");
+var import_base = require("./base.js");
+var import_permission = require("./permission.js");
+var import_local = require("../local/index.js");
+var import_local2 = require("../local/local.js");
+var import_order = require("./order.js");
+var import_progress = require("./progress.js");
+var import_order2 = require("./order.js");
+var import_permission2 = require("./permission.js");
+var import_util2 = require("../query/util.js");
+var import_received = require("../query/received.js");
+class CallService extends import_base.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) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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 (0, import_common.GetObjectExisted)(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        import_object.ObjectType.Service,
+        this.object_address
+      );
+      if (!this.content)
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallService_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      this.parameter_type = (0, import_util.parseObjectType)(
+        this.content.type_raw,
+        "service::Service"
+      );
+      if (!this.permission_address) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallService_Data.data.object.permission is empty"
+        );
+      }
+      if (!(0, import_common.IsValidArgType)(this.parameter_type)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidArgType,
+          "CallService_Data.data.object.type_parameter is empty"
+        );
+      }
+    } else {
+      const n = (0, import_common.GetObject)(
+        this.data.object
+      );
+      this.permission_address = await (0, import_common.GetObjectExisted)(n?.permission);
+      this.new_permission_description = (0, import_common.GetObjectDescription)(
+        n?.permission
+      );
+      this.parameter_type = n?.type_parameter;
+      if (!(0, import_common.IsValidArgType)(this.parameter_type)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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(import_permission.BuiltinPermissionIndex.SERVICE_NEW);
+    }
+    if (this.data?.order_new) {
+      if (!this.content) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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(import_permission.BuiltinPermissionIndex.SERVICE_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.location != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_LOCATION);
+    }
+    if (this.permission_address && this.data?.repositories != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_REPOSITORY);
+    }
+    if (this.permission_address && this.data?.sales != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_SALES);
+    }
+    if (this.permission_address && this.data?.machine !== void 0) {
+      this.checkNotPublished("machine");
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_MACHINE);
+    }
+    if (this.permission_address && this.data?.discount != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_DISCOUNT);
+    }
+    if (this.permission_address && this.data?.arbitrations != null) {
+      this.checkNotPublished("arbitrations");
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_ARBITRATION);
+    }
+    if (this.permission_address && this.data?.customer_required != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_CUSTOMER_INFO_REQUIRED);
+    }
+    if (this.permission_address && this.data?.pause !== void 0) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_PAUSE);
+    }
+    if (this.permission_address && this.data?.publish) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_PUBLISH);
+    }
+    if (this.permission_address && this.data?.order_allocators !== void 0) {
+      this.checkNotPublished("order_allocators");
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_ORDER_ALLOCATOR);
+    }
+    if (this.permission_address && this.data?.compensation_fund_add != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_COMPENSATION_FUND_DEPOSIT);
+    }
+    if (this.permission_address && this.data?.compensation_locked_time_add !== void 0) {
+      add_perm(
+        import_permission.BuiltinPermissionIndex.SERVICE_COMPENSATION_LOCKED_TIME_ADD
+      );
+    }
+    if (this.permission_address && this.data?.rewards != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_REWARD);
+    }
+    if (this.permission_address && this.data?.compensation_fund_receive != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_COMPENSATION_FUND_RECEIVE);
+    }
+    if (this.permission_address && this.data?.owner_receive != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.SERVICE_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data?.um !== void 0) {
+      add_perm(import_permission.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 = (0, import_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) {
+      (0, import_exception.W_ERROR)(
+        import_exception.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 import_local2.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) {
+        (0, import_exception.W_ERROR)(import_exception.WErrors.Fail, "Buy failed, no order created");
+      }
+      if (n?.agents != null) {
+        (0, import_order.agent_set)(tx, {
+          order: buyResult.order,
+          agents: await (0, import_local.GetManyAccountOrMark_Address)(n.agents)
+        });
+      }
+      if (n?.order_required_info !== void 0) {
+        await (0, import_order.order_required_info_update)(
+          tx,
+          buyResult.order,
+          n.order_required_info
+        );
+      }
+      if (n?.transfer != null) {
+        await (0, import_order.owner_change)(tx, {
+          order: buyResult.order,
+          new_owner: n.transfer
+        });
+      }
+      if (n?.namedNewAllocation != null && buyResult?.allocation) {
+        await this.new_with_mark(
+          env,
+          tx,
+          import_object.ObjectType.Allocation,
+          buyResult?.allocation,
+          (0, import_common.GetObject)(n.namedNewAllocation)
+        );
+      }
+      if (buyResult?.progress) {
+        if (n?.namedNewProgress != null) {
+          await this.new_with_mark(
+            env,
+            tx,
+            import_object.ObjectType.Progress,
+            (0, import_progress.create)(tx, buyResult?.progress),
+            (0, import_common.GetObject)(n.namedNewProgress)
+          );
+        } else {
+          (0, import_progress.create)(tx, buyResult?.progress);
+        }
+      }
+      if (buyResult?.order) {
+        const addr = (0, import_order2.create)(tx, buyResult?.order);
+        if (n?.namedNewOrder != null) {
+          await this.new_with_mark(
+            env,
+            tx,
+            import_object.ObjectType.Order,
+            addr,
+            (0, import_common.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.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 import_local2.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              "CallService_Data.data.repositories.objects:" + this.data.repositories.objects
+            );
+          }
+          const addrs = await import_local2.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) {
+            (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,
+              this.parameter_type,
+              permission,
+              passport
+            );
+          }
+          const rewards = await (0, import_util2.queryObjectsWithType)(
+            env,
+            this.data.rewards.objects,
+            import_object.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          const addrs = await import_local2.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.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 (0, import_util2.queryObjectsWithType)(
+            env,
+            this.data.arbitrations.objects,
+            import_object.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `arbitrations count exceeds maximum limit ${MAX_ARBITRATION_COUNT}`
+            );
+          }
+          const addrs = await import_local2.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 import_local2.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 import_local2.LocalMark.Instance().get_address(
+          this.data.machine
+        );
+        if (m) {
+          this.data.machine = m;
+        } else {
+          (0, import_exception.W_ERROR)(
+            import_exception.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 (0, import_allocation.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 (0, import_received.query_received)({
+          object: this.object_address,
+          network: env.network,
+          no_cache: env.no_cache
+        });
+        if (Array.isArray(received)) {
+          (0, import_exception.W_ERROR)(
+            import_exception.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) {
+          (0, import_exception.W_ERROR)(
+            import_exception.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(
+            [
+              import_local2.LocalMark.Instance().get_address(item.id),
+              import_local2.LocalMark.Instance().get_address(item.payment)
+            ]
+          );
+          if (!received_object || !payment_object) {
+            (0, import_exception.W_ERROR)(
+              import_exception.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 (0, import_received.query_received)({
+          object: this.object_address,
+          all_type: true,
+          network: env.network,
+          no_cache: env.no_cache
+        });
+      }
+      await (0, import_util.owner_receive)(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        this.parameter_type,
+        (name) => `${import_common.PackageAddress}::service::${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,
+            "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 = (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.Service,
+        create(tx, object, this.parameter_type),
+        (0, import_common.GetObject)(this.data?.object)
+      );
+    }
+  }
+  order_allowed() {
+    if (this.content?.bPaused) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "Service is paused");
+      return false;
+    }
+    if (this.content?.bPublished !== true) {
+      (0, import_exception.W_ERROR)(import_exception.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" && !(0, import_common.isValidLongName)(sale2.name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Name ${sale2.name} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (sale2.wip.length > MAX_WIP_LENGTH) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `WIP ${sale2.wip} exceeds maximum length ${MAX_WIP_LENGTH}`
+    );
+  }
+  if (!(0, import_common.isValidHttpUrl)(sale2.wip)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidHttpUrl,
+      `WIP ${sale2.wip} is not a valid HTTP/HTTPS URL`
+    );
+  }
+  if (sale2.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `WIP hash ${sale2.wip_hash} exceeds maximum length ${MAX_WIP_HASH_LENGTH}`
+    );
+  }
+  return tx.moveCall({
+    target: (0, import_common.serviceFn)("sale"),
+    arguments: [
+      (0, import_common.toTxString)(tx, sale2.name),
+      tx.pure.u64(sale2.price),
+      tx.pure.u64(sale2.stock),
+      tx.pure.bool(sale2.suspension),
+      (0, import_common.toTxString)(tx, sale2.wip),
+      (0, import_common.toTxString)(tx, sale2.wip_hash)
+    ]
+  });
+}
+function quote_item(tx, item) {
+  if (!(0, import_common.isValidLongName)(item.name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Quote item name ${item.name} is not valid`
+    );
+  }
+  if (!(0, import_common.isValidU64)(item.stock)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU64,
+      `Quote item stock ${item.stock} is not valid`
+    );
+  }
+  if (item.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Quote item wip_hash ${item.wip_hash} exceeds maximum length ${MAX_WIP_HASH_LENGTH}`
+    );
+  }
+  return tx.moveCall({
+    target: (0, import_common.serviceFn)("quote_item"),
+    arguments: [
+      (0, import_common.toTxString)(tx, item.name),
+      tx.pure.u64(item.stock),
+      (0, import_common.toTxString)(tx, item.wip_hash)
+    ]
+  });
+}
+function discount_send(tx, discount2, recipient) {
+  if (discount2.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([...discount2, recipient]);
+  if (discount2.length > MAX_DISCOUNT_COUNT_ONCE) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount count ${discount2.length} exceeds maximum limit ${MAX_DISCOUNT_COUNT_ONCE}`
+    );
+  }
+  if (discount2.length === 1) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("discount_send_singleton"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, discount2[0]),
+        tx.pure.address(recipient)
+      ]
+    });
+    return;
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("discount_send"),
+      arguments: [
+        tx.makeMoveVec({
+          elements: discount2,
+          type: `${import_common.PackageAddress}::service::Discount`
+        }),
+        tx.pure.address(recipient)
+      ]
+    });
+  }
+}
+function discount_destroy(tx, discount2) {
+  (0, import_util.validObjects)([...discount2]);
+  discount2.forEach((item) => {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("discount_destroy"),
+      arguments: [(0, import_common.toTxObject)(tx, item)]
+    });
+  });
+}
+const buy = async (env, tx, service, service_type, machine, buy2, passport) => {
+  if (buy2.items.length === 0) {
+    return void 0;
+  }
+  (0, import_util.validObjects)([service, buy2.discount, machine, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Buy service type ${service_type} is not valid`
+    );
+  }
+  if (!(0, import_common.isValidArray)(buy2.items, (item) => {
+    if (!(0, import_common.isValidLongName)(item.name)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Buy item name ${item.name} is not valid`
+      );
+    }
+    if (!(0, import_common.isValidU64)(item.stock)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.IsValidU64,
+        `Buy item stock ${item.stock} is not valid`
+      );
+    }
+    return true;
+  })) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "Buy items is not valid");
+  }
+  if (typeof buy2.payment_remark === "string" && !(0, import_common.isValidName)(buy2.payment_remark)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Buy payment remark ${buy2.payment_remark} is not valid`
+    );
+  }
+  buy2.payment_remark = buy2.payment_remark || "";
+  if (buy2.payment_index != null && !(0, import_common.isValidU64)(buy2.payment_index)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU64,
+      `Buy payment index ${buy2.payment_index} is not valid`
+    );
+  }
+  const coinParam = await (0, import_base.getCoinParam)(env, tx, buy2.total_pay, service_type);
+  buy2.discount = await import_local2.LocalMark.Instance().get_address(buy2.discount);
+  let quote = void 0;
+  if (buy2.discount) {
+    quote = tx.moveCall({
+      target: (0, import_common.serviceFn)("quote_with_discount"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        tx.makeMoveVec({
+          elements: buy2.items.map((item) => quote_item(tx, item)),
+          type: `${import_common.PackageAddress}::service::QuoteItem`
+        }),
+        (0, import_common.toTxObject)(tx, buy2.discount)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    quote = tx.moveCall({
+      target: (0, import_common.serviceFn)("quote"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        tx.makeMoveVec({
+          elements: buy2.items.map((item) => quote_item(tx, item)),
+          type: `${import_common.PackageAddress}::service::QuoteItem`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+  let order;
+  if (passport) {
+    order = tx.moveCall({
+      target: (0, import_common.serviceFn)("buy_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, passport),
+        quote,
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    order = tx.moveCall({
+      target: (0, import_common.serviceFn)("buy"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        quote,
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+  const result = {
+    order
+  };
+  result.allocation = tx.moveCall({
+    target: (0, import_common.serviceFn)("order_allocation"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, service),
+      (0, import_common.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: (0, import_common.serviceFn)("order_progress"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, order),
+        (0, import_common.toTxObject)(tx, machine),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+  return result;
+};
+function newService(tx, service_type, permission, description, passport) {
+  (0, import_util.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 (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `New service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: (0, import_common.serviceFn)("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()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    return tx.moveCall({
+      target: (0, import_common.serviceFn)("new"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function description_set(tx, service, service_type, permission, description, passport) {
+  (0, import_util.validObjects)([service, 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 (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Description set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("description_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, description)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("description_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, description)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function um_set(tx, service, service_type, permission, um, passport) {
+  (0, import_util.validObjects)([service, permission]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Service type ${service_type} is not valid`
+    );
+  }
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)(`um_set_with_passport`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          passport,
+          (0, import_common.toTxObject)(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)(`um_set`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)(`um_none_with_passport`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)(`um_none`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  }
+}
+function location_set(tx, service, service_type, permission, location, passport) {
+  (0, import_util.validObjects)([service, 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 (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Location set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("location_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, location)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("location_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, location)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function create(tx, service, service_type) {
+  (0, import_util.validObjects)([service]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Create service type ${service_type} is not valid`
+    );
+  }
+  return tx.moveCall({
+    target: (0, import_common.serviceFn)("create"),
+    arguments: [(0, import_common.toTxObject)(tx, service)],
+    typeArguments: [service_type]
+  });
+}
+function sales_add(tx, service, service_type, permission, sales, passport) {
+  if (sales.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sales add service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${import_common.PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${import_common.PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sales_remove(tx, service, service_type, permission, sales_name, passport) {
+  if (sales_name.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sales remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("string", sales_name)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("string", sales_name)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sales_clear(tx, service, service_type, permission, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sales clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_clear"),
+      arguments: [(0, import_common.toTxObject)(tx, service), (0, import_common.toTxObject)(tx, permission)],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sales_set(tx, service, service_type, permission, sales, passport) {
+  if (sales.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sales set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${import_common.PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sales_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.makeMoveVec({
+          elements: sales.map((s) => sale(tx, s)),
+          type: `${import_common.PackageAddress}::service::Sale`
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function price_add(tx, service, service_type, permission, sale_name, price_add2, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Price add service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !(0, import_common.isValidLongName)(sale_name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!(0, import_common.isValidU64)(price_add2)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU64, `Price add ${price_add2} is not valid`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("price_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.u64(price_add2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("price_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Price reduce service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !(0, import_common.isValidLongName)(sale_name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!(0, import_common.isValidU64)(price_reduce2)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU64,
+      `Price reduce ${price_reduce2} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("price_reduce_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.u64(price_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("price_reduce"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Stock add service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !(0, import_common.isValidLongName)(sale_name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!(0, import_common.isValidU64)(stock_add2)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU64, `Stock add ${stock_add2} is not valid`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("stock_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.u64(stock_add2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("stock_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Stock reduce service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !(0, import_common.isValidLongName)(sale_name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (!(0, import_common.isValidU64)(stock_reduce2)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU64,
+      `Stock reduce ${stock_reduce2} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("stock_reduce_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.u64(stock_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("stock_reduce"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.u64(stock_reduce2)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function sale_suspension(tx, service, service_type, permission, sale_name, suspension, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sale suspension service type ${service_type} is not valid`
+    );
+  }
+  if (typeof sale_name === "string" && !(0, import_common.isValidLongName)(sale_name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Sale name ${sale_name} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sale_suspension_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.bool(suspension)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("sale_suspension"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, sale_name),
+        tx.pure.bool(suspension)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function repository_add(tx, service, service_type, permission, repository, passport) {
+  (0, import_util.validObjects)([service, permission, repository, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Repository add service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("repository_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxObject)(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("repository_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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;
+  }
+  (0, import_util.validObjects)([service, permission, passport, ...repositories]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Repository remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("repository_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", repositories),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("repository_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", repositories),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function repository_clear(tx, service, service_type, permission, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Repository clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("repository_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("repository_clear"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function buy_guard_set(tx, service, service_type, permission, guard, passport) {
+  (0, import_util.validObjects)([service, permission, guard, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Buy guard set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    if (guard) {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("buy_guard_set_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, passport),
+          (0, import_common.toTxObject)(tx, guard),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("buy_guard_none_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, passport),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  } else {
+    if (guard) {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("buy_guard_set"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, guard),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("buy_guard_none"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  }
+}
+function machine_set(tx, service, service_type, permission, machine, passport) {
+  (0, import_util.validObjects)([service, permission, machine, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Machine set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    if (machine) {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("machine_set_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, passport),
+          (0, import_common.toTxObject)(tx, machine),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("machine_none_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, passport),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  } else {
+    if (machine) {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("machine_set"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, machine),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.serviceFn)("machine_set_none"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, service),
+          (0, import_common.toTxObject)(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [service_type]
+      });
+    }
+  }
+}
+function publish(tx, service, service_type, permission, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Publish service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("publish_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("publish"),
+      arguments: [(0, import_common.toTxObject)(tx, service), (0, import_common.toTxObject)(tx, permission)],
+      typeArguments: [service_type]
+    });
+  }
+}
+function pause(tx, service, service_type, permission, bPaused, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Pause service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("pause_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.bool(bPaused),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("pause"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.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) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Customer required set size ${required_info.length} is exceed maximum size ${MAX_REQUIRED_INFO_SIZE}`
+    );
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Customer required set service type ${service_type} is not valid`
+    );
+  }
+  required_info.forEach((item) => {
+    if (!(0, import_common.isValidName)(item)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Customer required info ${item} is exceed maximum length ${import_common.MAX_NAME_LENGTH} or start with "0x"`
+      );
+    }
+  });
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("custom_required_info_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("string", required_info)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("custom_required_info_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("string", required_info)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function arbitrations_add(tx, service, service_type, permission, arbitration, arbitration_type, passport) {
+  (0, import_util.validObjects)([service, permission, arbitration, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Arbitrations add service type ${service_type} is not valid`
+    );
+  }
+  if (!(0, import_common.IsValidArgType)(arbitration_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Arbitrations add arbitration type ${arbitration_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("arbitration_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxObject)(tx, arbitration),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("arbitrations_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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;
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Arbitrations remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("arbitration_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", arbitrations),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("arbitration_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", arbitrations),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function arbitration_clear(tx, service, service_type, permission, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Arbitrations clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("arbitration_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("arbitration_clear"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+async function compensation_fund_add(env, tx, service, service_type, permission, coin, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation fund add service type ${service_type} is not valid`
+    );
+  }
+  const coinParam = await (0, import_base.getCoinParam)(env, tx, coin, service_type);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_fund_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        coinParam
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_fund_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        coinParam
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function compensation_lock_duration_set(tx, service, service_type, permission, duration_ms, passport) {
+  if (!(0, import_common.isValidU64)(duration_ms) || duration_ms === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation lock duration set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_lock_duration_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.u64(duration_ms)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_lock_duration_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.u64(duration_ms)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function order_allocators_set(tx, service, service_type, permission, allocators2, passport) {
+  (0, import_util.validObjects)([service, permission, allocators2, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Order allocators set service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("order_allocators_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object.option({
+          type: `${import_common.PackageAddress}::allocation::Allocators`,
+          value: allocators2 ?? null
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("order_allocators_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object.option({
+          type: `${import_common.PackageAddress}::allocation::Allocators`,
+          value: allocators2 ?? null
+        })
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function reward_add(tx, service, service_type, permission, reward, reward_type, passport) {
+  (0, import_util.validObjects)([service, permission, reward, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Rewards add service type ${service_type} is not valid`
+    );
+  }
+  if (!(0, import_common.IsValidArgType)(reward_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Rewards add reward type ${reward_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("reward_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (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: [service_type, reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("reward_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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;
+  }
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Rewards remove service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("reward_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("reward_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function reward_clear(tx, service, service_type, permission, passport) {
+  (0, import_util.validObjects)([service, permission, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Rewards clear service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("reward_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("reward_clear"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object.mutRegistrar()
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function compensation_fund_receive(tx, service, service_type, permission, received_object, payment, passport) {
+  if (!payment) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation fund receive payment is required`
+    );
+  }
+  (0, import_util.validObjects)([service, permission, received_object, payment, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation fund receive service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_fund_receive_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxObject)(tx, received_object),
+        (0, import_common.toTxObject)(tx, payment)
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_fund_receive"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, received_object),
+        (0, import_common.toTxObject)(tx, payment)
+      ],
+      typeArguments: [service_type]
+    });
+  }
+}
+function compensation_fund_withdraw(tx, service, service_type, payment_info, receipt, permission, passport) {
+  (0, import_util.validObjects)([service, permission, receipt, payment_info, passport]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation fund withdraw service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_fund_withdraw_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.address(receipt),
+        (0, import_common.toTxObject)(tx, payment_info),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("compensation_fund_withdraw"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.address(receipt),
+        (0, import_common.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 (0, import_local.GetManyAccountOrMark_Address)(discount2.recipient);
+  }
+  if (recipient.length === 0 || discount2.count === 0) {
+    return;
+  }
+  if (recipient.length > MAX_DISCOUNT_RECEIVER_ONCE) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount recipient length ${recipient.length} is exceed max ${MAX_DISCOUNT_RECEIVER_ONCE}`
+    );
+  }
+  if (!(0, import_common.isValidName)(discount2.name)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount name ${discount2.name} is not valid`
+    );
+  }
+  if (!(0, import_common.isValidU16)(discount2.count) || discount2.count > MAX_DISCOUNT_COUNT_ONCE) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount count ${discount2.count} is exceed max ${MAX_DISCOUNT_COUNT_ONCE}`
+    );
+  }
+  if (recipient.length * discount2.count > MAX_DISCOUNT_TOTAL_COUNT) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount total count ${recipient.length * discount2.count} is exceed max ${MAX_DISCOUNT_TOTAL_COUNT}`
+    );
+  }
+  if (discount2.benchmark != null && !(0, import_common.isValidU64)(discount2.benchmark)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount benchmark ${discount2.benchmark} is not valid`
+    );
+  }
+  const start = discount2.time_ms_start ?? Date.now();
+  if (discount2.time_ms_end < start) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount time_ms_end ${discount2.time_ms_end} is not valid`
+    );
+  }
+  if (discount2.discount_value != null && !(0, import_common.isValidU64)(discount2.discount_value)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount discount_value ${discount2.discount_value} is not valid`
+    );
+  }
+  (0, import_util.validObjects)([service, permission, passport, ...recipient]);
+  if (!(0, import_common.IsValidArgType)(service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Discount service type ${service_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.serviceFn)("discount_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.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: (0, import_common.serviceFn)("discount"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, service),
+        (0, import_common.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]
+    });
+  }
+}