wowok 2.1.10 → 2.1.12

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

@@ -1,2468 +1,1962 @@
 "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);
-      }
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buy = exports.DISCOUNT_TYPE_MINUS = exports.DISCOUNT_TYPE_RATES = exports.DEFAULT_COMPENSATION_LOCK_DURATION = exports.MAX_REQUIRED_INFO_SIZE = exports.MAX_DISCOUNT_TOTAL_COUNT = exports.MAX_DISCOUNT_RECEIVER_ONCE = exports.MAX_DISCOUNT_COUNT_ONCE = exports.MAX_PUBKEY_LENGTH = exports.MAX_CUSTOMER_REQUIRED_INFO_COUNT = exports.MAX_REWARD_COUNT = exports.MAX_ARBITRATION_COUNT = exports.MAX_REPOSITORY_COUNT = exports.MAX_SALE_COUNT = exports.CallService = void 0;
+exports.discount_send = discount_send;
+exports.discount_destroy = discount_destroy;
+exports.newService = newService;
+exports.description_set = description_set;
+exports.um_set = um_set;
+exports.location_set = location_set;
+exports.create = create;
+exports.sales_add = sales_add;
+exports.sales_remove = sales_remove;
+exports.sales_clear = sales_clear;
+exports.sales_set = sales_set;
+exports.price_add = price_add;
+exports.price_reduce = price_reduce;
+exports.stock_add = stock_add;
+exports.stock_reduce = stock_reduce;
+exports.sale_suspension = sale_suspension;
+exports.repository_add = repository_add;
+exports.repository_remove = repository_remove;
+exports.repository_clear = repository_clear;
+exports.buy_guard_set = buy_guard_set;
+exports.machine_set = machine_set;
+exports.publish = publish;
+exports.pause = pause;
+exports.customer_required_set = customer_required_set;
+exports.arbitrations_add = arbitrations_add;
+exports.arbitrations_remove = arbitrations_remove;
+exports.arbitration_clear = arbitration_clear;
+exports.compensation_fund_add = compensation_fund_add;
+exports.compensation_lock_duration_set = compensation_lock_duration_set;
+exports.order_allocators_set = order_allocators_set;
+exports.reward_add = reward_add;
+exports.reward_remove = reward_remove;
+exports.reward_clear = reward_clear;
+exports.compensation_fund_receive = compensation_fund_receive;
+exports.compensation_fund_withdraw = compensation_fund_withdraw;
+exports.discount = discount;
+const common_js_1 = require("../common.js");
+const exception_js_1 = require("../exception.js");
+const object_js_1 = require("../query/object.js");
+const util_js_1 = require("../util.js");
+const allocation_js_1 = require("./allocation.js");
+const base_js_1 = require("./base.js");
+const permission_js_1 = require("./permission.js");
+const index_js_1 = require("../local/index.js");
+const local_js_1 = require("../local/local.js");
+const order_js_1 = require("./order.js");
+const progress_js_1 = require("./progress.js");
+const order_js_2 = require("./order.js");
+const permission_js_2 = require("./permission.js");
+const util_js_2 = require("../query/util.js");
+const received_js_1 = require("../query/received.js");
+class CallService extends base_js_1.CallBase {
+    data;
+    object_address = undefined;
+    permission_address = undefined;
+    new_permission_description = undefined;
+    parameter_type = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async prepare(env) {
+        await super.prepare(env);
+        if (!this.object_address) {
+            this.object_address = await (0, common_js_1.GetObjectExisted)(this.data?.object);
+        }
+        if (this.object_address) {
+            await this.update_content(env, object_js_1.ObjectType.Service, this.object_address);
+            if (!this.content)
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallService_Data.data.object:" + this.object_address);
+            this.permission_address = this.content.permission;
+            this.parameter_type = (0, util_js_1.parseObjectType)(this.content.type_raw, "service::Service");
+            if (!this.permission_address) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallService_Data.data.object.permission is empty");
+            }
+            if (!(0, common_js_1.IsValidArgType)(this.parameter_type)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, "CallService_Data.data.object.type_parameter is empty");
+            }
+        }
+        else {
+            const n = (0, common_js_1.GetObject)(this.data.object);
+            this.permission_address = await (0, common_js_1.GetObjectExisted)(n?.permission);
+            this.new_permission_description = (0, common_js_1.GetObjectDescription)(n?.permission);
+            this.parameter_type = n?.type_parameter;
+            if (!(0, common_js_1.IsValidArgType)(this.parameter_type)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, "CallService_Data.data.object.type_parameter invalid");
+            }
+        }
+    }
+    async call(env) {
+        await this.prepare(env); // prepare first.
+        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(permission_js_1.BuiltinPermissionIndex.SERVICE_NEW);
+        }
+        if (this.data?.order_new) {
+            if (!this.content) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.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(permission_js_1.BuiltinPermissionIndex.SERVICE_DESCRIPTION);
+        }
+        if (this.permission_address && this.data?.location != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_LOCATION);
+        }
+        if (this.permission_address && this.data?.repositories != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_REPOSITORY);
+        }
+        if (this.permission_address && this.data?.sales != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_SALES);
+        }
+        if (this.permission_address && this.data?.machine !== undefined) {
+            this.checkNotPublished("machine");
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_MACHINE);
+        }
+        if (this.permission_address && this.data?.discount != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_DISCOUNT);
+        }
+        if (this.permission_address && this.data?.arbitrations != null) {
+            this.checkNotPublished("arbitrations");
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_ARBITRATION);
+        }
+        if (this.permission_address && this.data?.customer_required != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_CUSTOMER_INFO_REQUIRED);
+        }
+        if (this.permission_address && this.data?.pause !== undefined) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_PAUSE);
+        }
+        if (this.permission_address && this.data?.publish) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_PUBLISH);
+        }
+        if (this.permission_address &&
+            this.data?.order_allocators !== undefined) {
+            this.checkNotPublished("order_allocators");
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_ORDER_ALLOCATOR);
+        }
+        if (this.permission_address &&
+            this.data?.compensation_fund_add != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_COMPENSATION_FUND_DEPOSIT);
+        }
+        if (this.permission_address &&
+            this.data?.compensation_locked_time_add !== undefined) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_COMPENSATION_LOCKED_TIME_ADD);
+        }
+        if (this.permission_address && this.data?.rewards != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_REWARD);
+        }
+        if (this.permission_address &&
+            this.data?.compensation_fund_receive != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_COMPENSATION_FUND_RECEIVE);
+        }
+        if (this.permission_address && this.data?.owner_receive != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.SERVICE_OWNER_RECEIVE);
+        }
+        if (this.permission_address && this.data?.um !== undefined) {
+            add_perm(permission_js_1.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, permission_js_1.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, exception_js_1.W_ERROR)(exception_js_1.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 local_js_1.LocalMark.Instance().get_address(this.data.order_new.buy.discount);
+            buyResult = await (0, exports.buy)(env, tx, object, this.parameter_type, this.content.machine, n.buy, passport);
+            if (!buyResult) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.Fail, "Buy failed, no order created");
+            }
+            if (n?.agents != null) {
+                (0, order_js_1.agent_set)(tx, {
+                    order: buyResult.order,
+                    agents: await (0, index_js_1.GetManyAccountOrMark_Address)(n.agents),
+                });
+            }
+            if (n?.order_required_info !== undefined) {
+                await (0, order_js_1.order_required_info_update)(tx, buyResult.order, n.order_required_info);
+            }
+            if (n?.transfer != null) {
+                await (0, order_js_1.owner_change)(tx, {
+                    order: buyResult.order,
+                    new_owner: n.transfer,
+                });
+            }
+            if (n?.namedNewAllocation != null && buyResult?.allocation) {
+                await this.new_with_mark(env, tx, object_js_1.ObjectType.Allocation, buyResult?.allocation, (0, common_js_1.GetObject)(n.namedNewAllocation));
+            }
+            if (buyResult?.progress) {
+                if (n?.namedNewProgress != null) {
+                    await this.new_with_mark(env, tx, object_js_1.ObjectType.Progress, (0, progress_js_1.create)(tx, buyResult?.progress), (0, common_js_1.GetObject)(n.namedNewProgress));
+                }
+                else {
+                    (0, progress_js_1.create)(tx, buyResult?.progress);
+                }
+            }
+            if (buyResult?.order) {
+                const addr = (0, order_js_2.create)(tx, buyResult?.order);
+                if (n?.namedNewOrder != null) {
+                    await this.new_with_mark(env, tx, object_js_1.ObjectType.Order, addr, (0, common_js_1.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 >
+                        exports.MAX_REPOSITORY_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.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 local_js_1.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 >
+                        exports.MAX_REPOSITORY_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallService_Data.data.repositories.objects:" +
+                            this.data.repositories.objects);
+                    }
+                    const addrs = await local_js_1.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 > exports.MAX_REWARD_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `rewards count exceeds maximum limit ${exports.MAX_REWARD_COUNT}`);
+                    }
+                    if (this.data.rewards.op === "set") {
+                        reward_clear(tx, object, this.parameter_type, permission, passport);
+                    }
+                    // 无需localmark查询
+                    const rewards = await (0, util_js_2.queryObjectsWithType)(env, this.data.rewards.objects, object_js_1.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 > exports.MAX_REWARD_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `rewards count exceeds maximum limit ${exports.MAX_REWARD_COUNT}`);
+                    }
+                    const addrs = await local_js_1.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 >
+                        exports.MAX_ARBITRATION_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `arbitrations count exceeds maximum limit ${exports.MAX_ARBITRATION_COUNT}`);
+                    }
+                    if (this.data.arbitrations.op === "set") {
+                        arbitration_clear(tx, object, this.parameter_type, permission, passport);
+                    }
+                    const arbitrations = await (0, util_js_2.queryObjectsWithType)(env, this.data.arbitrations.objects, object_js_1.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 >
+                        exports.MAX_ARBITRATION_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `arbitrations count exceeds maximum limit ${exports.MAX_ARBITRATION_COUNT}`);
+                    }
+                    const addrs = await local_js_1.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 local_js_1.LocalMark.Instance().get_many_address_availables(this.data.discount_destroy);
+            discount_destroy(tx, r);
+        }
+        if (this.data.machine !== undefined) {
+            if (this.data.machine) {
+                const m = await local_js_1.LocalMark.Instance().get_address(this.data.machine);
+                if (m) {
+                    this.data.machine = m;
+                }
+                else {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.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 !== undefined) {
+            // localMark 查询在allocators中完成
+            order_allocators_set(tx, object, this.parameter_type, permission, this.data.order_allocators
+                ? await (0, allocation_js_1.allocators)(tx, this.data.order_allocators)
+                : null, passport);
+        }
+        if (this.data.compensation_fund_add != null) {
+            // getCoinParam中完成地址查询
+            compensation_fund_add(env, tx, object, this.parameter_type, permission, this.data.compensation_fund_add, passport);
+        }
+        if (this.data.compensation_locked_time_add !== undefined) {
+            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, received_js_1.query_received)({
+                    object: this.object_address,
+                    network: env.network,
+                    no_cache: env.no_cache,
+                });
+                // 检查received的类型，如果是ReceivedNormal[]，需要转换为ReceivedBalance
+                if (Array.isArray(received)) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]");
+                }
+                else {
+                    // 如果是ReceivedBalance类型，直接赋值
+                    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, exception_js_1.W_ERROR)(exception_js_1.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([
+                        local_js_1.LocalMark.Instance().get_address(item.id),
+                        local_js_1.LocalMark.Instance().get_address(item.payment),
+                    ]);
+                    if (!received_object || !payment_object) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.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) {
+            // owner_receive 中完成地址查询
+            if (this.data.owner_receive === "recently") {
+                this.data.owner_receive = await (0, received_js_1.query_received)({
+                    object: this.object_address,
+                    all_type: true,
+                    network: env.network,
+                    no_cache: env.no_cache,
+                });
+            }
+            await (0, util_js_1.owner_receive)(tx, object, permission, this.data.owner_receive, this.parameter_type, (name) => `${common_js_1.PackageAddress}::service::${name}`, passport);
+        }
+        // 处理 um
+        if (this.data.um !== undefined) {
+            let um_address = null;
+            if (this.data.um) {
+                um_address =
+                    (await local_js_1.LocalMark.Instance().get_address(this.data.um)) ||
+                        null;
+                if (!um_address) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.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, common_js_1.GetObject)(this.data?.object);
+            await this.new_with_mark(env, tx, object_js_1.ObjectType.Permission, (0, permission_js_2.create)(tx, permission), (0, common_js_1.GetObject)(p.permission));
+        }
+        if (!this.object_address) {
+            await this.new_with_mark(env, tx, object_js_1.ObjectType.Service, create(tx, object, this.parameter_type), (0, common_js_1.GetObject)(this.data?.object));
+        }
+    }
+    checkPublished = (op) => {
+        if (this.content && !this.content.bPublished) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.Fail, `Service object has not been published yet, so the operation (${op}) cannot proceed.`);
+        }
+    };
+    checkNotPublished = (op) => {
+        if (this.content && this.content.bPublished) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.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.`);
+        }
     };
-    const add_perm = (index) => {
-      if (this.permission_address && !perms.includes(index)) {
-        perms.push(index);
-      }
+    checkNotPaused = (op) => {
+        if (this.content && this.content.bPaused) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.Fail, `Service object has been paused and operation (${op}) cannot proceed.`);
+        }
     };
-    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;
-  }
+    order_allowed() {
+        if (this.content?.bPaused) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "Service is paused");
+            return false;
+        }
+        if (this.content?.bPublished !== true) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.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;
+exports.CallService = CallService;
+// ================================================
+// 常量定义
+exports.MAX_SALE_COUNT = 50;
+exports.MAX_REPOSITORY_COUNT = 100;
+exports.MAX_ARBITRATION_COUNT = 20;
+exports.MAX_REWARD_COUNT = 20;
+exports.MAX_CUSTOMER_REQUIRED_INFO_COUNT = 10;
+exports.MAX_PUBKEY_LENGTH = 1024;
+exports.MAX_DISCOUNT_COUNT_ONCE = 1000;
+exports.MAX_DISCOUNT_RECEIVER_ONCE = 1000;
+exports.MAX_DISCOUNT_TOTAL_COUNT = 20000;
+exports.MAX_REQUIRED_INFO_SIZE = 20;
+exports.DEFAULT_COMPENSATION_LOCK_DURATION = 2592000000; // 30 days
+exports.DISCOUNT_TYPE_RATES = 0;
+exports.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 sale(tx, sale) {
+    if (typeof sale.name === "string" && !(0, common_js_1.isValidLongName)(sale.name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Name ${sale.name} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (sale.wip.length > MAX_WIP_LENGTH) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `WIP ${sale.wip} exceeds maximum length ${MAX_WIP_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidHttpUrl)(sale.wip)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidHttpUrl, `WIP ${sale.wip} is not a valid HTTP/HTTPS URL`);
+    }
+    if (sale.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `WIP hash ${sale.wip_hash} exceeds maximum length ${MAX_WIP_HASH_LENGTH}`);
+    }
+    return tx.moveCall({
+        target: (0, common_js_1.serviceFn)("sale"),
+        arguments: [
+            (0, common_js_1.toTxString)(tx, sale.name),
+            tx.pure.u64(sale.price),
+            tx.pure.u64(sale.stock),
+            tx.pure.bool(sale.suspension),
+            (0, common_js_1.toTxString)(tx, sale.wip),
+            (0, common_js_1.toTxString)(tx, sale.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)
-      ]
+    if (!(0, common_js_1.isValidLongName)(item.name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Quote item name ${item.name} is not valid`);
+    }
+    if (!(0, common_js_1.isValidU64)(item.stock)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Quote item stock ${item.stock} is not valid`);
+    }
+    if (item.wip_hash.length > MAX_WIP_HASH_LENGTH) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Quote item wip_hash ${item.wip_hash} exceeds maximum length ${MAX_WIP_HASH_LENGTH}`);
+    }
+    return tx.moveCall({
+        target: (0, common_js_1.serviceFn)("quote_item"),
+        arguments: [
+            (0, common_js_1.toTxString)(tx, item.name),
+            tx.pure.u64(item.stock),
+            (0, common_js_1.toTxString)(tx, item.wip_hash),
+        ],
     });
-  }
 }
-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)]
-    });
-  });
+function discount_send(tx, discount, recipient) {
+    if (discount.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([...discount, recipient]);
+    if (discount.length > exports.MAX_DISCOUNT_COUNT_ONCE) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount count ${discount.length} exceeds maximum limit ${exports.MAX_DISCOUNT_COUNT_ONCE}`);
+    }
+    if (discount.length === 1) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("discount_send_singleton"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, discount[0]),
+                tx.pure.address(recipient),
+            ],
+        });
+        return;
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("discount_send"),
+            arguments: [
+                tx.makeMoveVec({
+                    elements: discount,
+                    type: `${common_js_1.PackageAddress}::service::Discount`,
+                }),
+                tx.pure.address(recipient),
+            ],
+        });
+    }
 }
-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]
+function discount_destroy(tx, discount) {
+    (0, util_js_1.validObjects)([...discount]);
+    discount.forEach((item) => {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("discount_destroy"),
+            arguments: [(0, common_js_1.toTxObject)(tx, item)],
+        });
     });
-  }
-  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]
+}
+const buy = async (env, tx, service, service_type, machine, buy, passport) => {
+    if (buy.items.length === 0) {
+        return undefined;
+    }
+    (0, util_js_1.validObjects)([service, buy.discount, machine, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Buy service type ${service_type} is not valid`);
+    }
+    if (!(0, common_js_1.isValidArray)(buy.items, (item) => {
+        if (!(0, common_js_1.isValidLongName)(item.name)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Buy item name ${item.name} is not valid`);
+        }
+        if (!(0, common_js_1.isValidU64)(item.stock)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Buy item stock ${item.stock} is not valid`);
+        }
+        return true;
+    })) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "Buy items is not valid");
+    }
+    if (typeof buy.payment_remark === "string" &&
+        !(0, common_js_1.isValidName)(buy.payment_remark)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Buy payment remark ${buy.payment_remark} is not valid`);
+    }
+    buy.payment_remark = buy.payment_remark || "";
+    if (buy.payment_index != null && !(0, common_js_1.isValidU64)(buy.payment_index)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Buy payment index ${buy.payment_index} is not valid`);
+    }
+    const coinParam = await (0, base_js_1.getCoinParam)(env, tx, buy.total_pay, service_type);
+    buy.discount = await local_js_1.LocalMark.Instance().get_address(buy.discount);
+    let quote = undefined;
+    if (buy.discount) {
+        quote = tx.moveCall({
+            target: (0, common_js_1.serviceFn)("quote_with_discount"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                tx.makeMoveVec({
+                    elements: buy.items.map((item) => quote_item(tx, item)),
+                    type: `${common_js_1.PackageAddress}::service::QuoteItem`,
+                }),
+                (0, common_js_1.toTxObject)(tx, buy.discount),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        quote = tx.moveCall({
+            target: (0, common_js_1.serviceFn)("quote"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                tx.makeMoveVec({
+                    elements: buy.items.map((item) => quote_item(tx, item)),
+                    type: `${common_js_1.PackageAddress}::service::QuoteItem`,
+                }),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    let order;
+    if (passport) {
+        order = tx.moveCall({
+            target: (0, common_js_1.serviceFn)("buy_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, passport),
+                quote,
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        order = tx.moveCall({
+            target: (0, common_js_1.serviceFn)("buy"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                quote,
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    const result = {
+        order: order,
+    };
+    result.allocation = tx.moveCall({
+        target: (0, common_js_1.serviceFn)("order_allocation"),
+        arguments: [
+            (0, common_js_1.toTxObject)(tx, service),
+            (0, common_js_1.toTxObject)(tx, order),
+            coinParam,
+            tx.pure.string(buy.payment_remark ?? ""),
+            tx.pure.u64(buy.payment_index || 0),
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
+        ],
+        typeArguments: [service_type],
     });
-  }
-  return result;
+    if (machine) {
+        result.progress = tx.moveCall({
+            target: (0, common_js_1.serviceFn)("order_progress"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, order),
+                (0, common_js_1.toTxObject)(tx, machine),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    return result;
 };
+exports.buy = buy;
+// ================================================
+// 构造函数和设置函数
 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]
-    });
-  }
+    (0, util_js_1.validObjects)([permission, passport]);
+    if (typeof description === "string" && !(0, common_js_1.isValidDescription)(description)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidDescription, `Description exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    }
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `New service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        return tx.moveCall({
+            target: (0, common_js_1.serviceFn)("new_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.serviceFn)("new"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (typeof description === "string" && !(0, common_js_1.isValidDescription)(description)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidDescription, `Description exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    }
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Description set service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("description_set_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, description),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("description_set"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-      });
+    (0, util_js_1.validObjects)([service, permission]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Service type ${service_type} is not valid`);
     }
-  } 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]
-      });
+    if (um) {
+        if (passport) {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)(`um_set_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    (0, common_js_1.toTxObject)(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)(`um_set`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+    }
+    else {
+        if (passport) {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)(`um_none_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)(`um_none`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (typeof location === "string" && !(0, common_js_1.isValidLongName)(location)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Location ${location} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Location set service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("location_set_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, location),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("location_set"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-  });
+    (0, util_js_1.validObjects)([service]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Create service type ${service_type} is not valid`);
+    }
+    return tx.moveCall({
+        target: (0, common_js_1.serviceFn)("create"),
+        arguments: [(0, common_js_1.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]
-    });
-  }
+    if (sales.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sales add service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.makeMoveVec({
+                    elements: sales.map((s) => sale(tx, s)),
+                    type: `${common_js_1.PackageAddress}::service::Sale`,
+                }),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.makeMoveVec({
+                    elements: sales.map((s) => sale(tx, s)),
+                    type: `${common_js_1.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]
-    });
-  }
+    if (sales_name.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sales remove service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.vector("string", sales_name),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sales clear service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_clear_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_clear"),
+            arguments: [(0, common_js_1.toTxObject)(tx, service), (0, common_js_1.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]
-    });
-  }
+    if (sales.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sales set service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_set_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.makeMoveVec({
+                    elements: sales.map((s) => sale(tx, s)),
+                    type: `${common_js_1.PackageAddress}::service::Sale`,
+                }),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sales_set"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.makeMoveVec({
+                    elements: sales.map((s) => sale(tx, s)),
+                    type: `${common_js_1.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_add(tx, service, service_type, permission, sale_name, price_add, passport) {
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Price add service type ${service_type} is not valid`);
+    }
+    if (typeof sale_name === "string" && !(0, common_js_1.isValidLongName)(sale_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sale name ${sale_name} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidU64)(price_add)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Price add ${price_add} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("price_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(price_add),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("price_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(price_add),
+            ],
+            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 price_reduce(tx, service, service_type, permission, sale_name, price_reduce, passport) {
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Price reduce service type ${service_type} is not valid`);
+    }
+    if (typeof sale_name === "string" && !(0, common_js_1.isValidLongName)(sale_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sale name ${sale_name} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidU64)(price_reduce)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Price reduce ${price_reduce} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("price_reduce_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(price_reduce),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("price_reduce"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(price_reduce),
+            ],
+            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_add(tx, service, service_type, permission, sale_name, stock_add, passport) {
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Stock add service type ${service_type} is not valid`);
+    }
+    if (typeof sale_name === "string" && !(0, common_js_1.isValidLongName)(sale_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sale name ${sale_name} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidU64)(stock_add)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Stock add ${stock_add} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("stock_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(stock_add),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("stock_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(stock_add),
+            ],
+            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 stock_reduce(tx, service, service_type, permission, sale_name, stock_reduce, passport) {
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Stock reduce service type ${service_type} is not valid`);
+    }
+    if (typeof sale_name === "string" && !(0, common_js_1.isValidLongName)(sale_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sale name ${sale_name} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidU64)(stock_reduce)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Stock reduce ${stock_reduce} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("stock_reduce_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(stock_reduce),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("stock_reduce"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.u64(stock_reduce),
+            ],
+            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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sale suspension service type ${service_type} is not valid`);
+    }
+    if (typeof sale_name === "string" && !(0, common_js_1.isValidLongName)(sale_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Sale name ${sale_name} exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sale_suspension_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, sale_name),
+                tx.pure.bool(suspension),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("sale_suspension"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, repository, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Repository add service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("repository_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxObject)(tx, repository),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("repository_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-    });
-  }
+    if (repositories.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport, ...repositories]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Repository remove service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("repository_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.vector("address", repositories),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("repository_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Repository clear service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("repository_clear_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("repository_clear"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-      });
+    (0, util_js_1.validObjects)([service, permission, guard, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Buy guard set service type ${service_type} is not valid`);
     }
-  } 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]
-      });
+    if (passport) {
+        if (guard) {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("buy_guard_set_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    (0, common_js_1.toTxObject)(tx, guard),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("buy_guard_none_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+    }
+    else {
+        if (guard) {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("buy_guard_set"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, guard),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("buy_guard_none"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.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]
-      });
+    (0, util_js_1.validObjects)([service, permission, machine, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Machine set service type ${service_type} is not valid`);
     }
-  } 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]
-      });
+    if (passport) {
+        if (machine) {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("machine_set_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("machine_none_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+    }
+    else {
+        if (machine) {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("machine_set"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [service_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.serviceFn)("machine_set_none"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, service),
+                    (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Publish service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("publish_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("publish"),
+            arguments: [(0, common_js_1.toTxObject)(tx, service), (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Pause service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("pause_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.bool(bPaused),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("pause"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
+    if (required_info.length > exports.MAX_REQUIRED_INFO_SIZE) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Customer required set size ${required_info.length} is exceed maximum size ${exports.MAX_REQUIRED_INFO_SIZE}`);
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Customer required set service type ${service_type} is not valid`);
+    }
+    required_info.forEach((item) => {
+        if (!(0, common_js_1.isValidName)(item)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Customer required info ${item} is exceed maximum length ${common_js_1.MAX_NAME_LENGTH} or start with "0x"`);
+        }
     });
-  }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("custom_required_info_set_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.vector("string", required_info),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("custom_required_info_set"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, arbitration, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitrations add service type ${service_type} is not valid`);
+    }
+    if (!(0, common_js_1.IsValidArgType)(arbitration_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitrations add arbitration type ${arbitration_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("arbitration_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("arbitrations_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-    });
-  }
+    if (arbitrations.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitrations remove service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("arbitration_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.vector("address", arbitrations),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("arbitration_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitrations clear service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("arbitration_clear_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("arbitration_clear"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation fund add service type ${service_type} is not valid`);
+    }
+    const coinParam = await (0, base_js_1.getCoinParam)(env, tx, coin, service_type);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_fund_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                coinParam,
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_fund_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    if (!(0, common_js_1.isValidU64)(duration_ms) || duration_ms === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation lock duration set service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_lock_duration_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.u64(duration_ms),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_lock_duration_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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 order_allocators_set(tx, service, service_type, permission, allocators, passport) {
+    (0, util_js_1.validObjects)([service, permission, allocators, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Order allocators set service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("order_allocators_set_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.object.option({
+                    type: `${common_js_1.PackageAddress}::allocation::Allocators`,
+                    value: allocators ?? null,
+                }),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("order_allocators_set"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.object.option({
+                    type: `${common_js_1.PackageAddress}::allocation::Allocators`,
+                    value: allocators ?? 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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, reward, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Rewards add service type ${service_type} is not valid`);
+    }
+    if (!(0, common_js_1.IsValidArgType)(reward_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Rewards add reward type ${reward_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("reward_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxObject)(tx, reward),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type, reward_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("reward_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.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]
-    });
-  }
+    if (rewards.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Rewards remove service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("reward_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.vector("address", rewards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("reward_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Rewards clear service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("reward_clear_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("reward_clear"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.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]
-    });
-  }
+    if (!payment) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation fund receive payment is required`);
+    }
+    (0, util_js_1.validObjects)([service, permission, received_object, payment, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation fund receive service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_fund_receive_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxObject)(tx, received_object),
+                (0, common_js_1.toTxObject)(tx, payment),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_fund_receive"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, received_object),
+                (0, common_js_1.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]
-    });
-  }
+    (0, util_js_1.validObjects)([service, permission, receipt, payment_info, passport]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation fund withdraw service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_fund_withdraw_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.address(receipt),
+                (0, common_js_1.toTxObject)(tx, payment_info),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("compensation_fund_withdraw"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.address(receipt),
+                (0, common_js_1.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]
-    });
-  }
+async function discount(tx, service, service_type, permission, discount, passport) {
+    let recipient = [];
+    if (Array.isArray(discount.recipient)) {
+        // 如果 recipient 是 string[] 类型，直接使用
+        recipient = discount.recipient;
+    }
+    else {
+        // 如果 recipient 是 ManyAccountOrMark_Address 类型，调用 GetManyAccountOrMark_Address
+        recipient = await (0, index_js_1.GetManyAccountOrMark_Address)(discount.recipient);
+    }
+    if (recipient.length === 0 || discount.count === 0) {
+        return;
+    }
+    if (recipient.length > exports.MAX_DISCOUNT_RECEIVER_ONCE) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount recipient length ${recipient.length} is exceed max ${exports.MAX_DISCOUNT_RECEIVER_ONCE}`);
+    }
+    if (!(0, common_js_1.isValidName)(discount.name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount name ${discount.name} is not valid`);
+    }
+    if (!(0, common_js_1.isValidU16)(discount.count) ||
+        discount.count > exports.MAX_DISCOUNT_COUNT_ONCE) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount count ${discount.count} is exceed max ${exports.MAX_DISCOUNT_COUNT_ONCE}`);
+    }
+    if (recipient.length * discount.count > exports.MAX_DISCOUNT_TOTAL_COUNT) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount total count ${recipient.length * discount.count} is exceed max ${exports.MAX_DISCOUNT_TOTAL_COUNT}`);
+    }
+    if (discount.benchmark != null && !(0, common_js_1.isValidU64)(discount.benchmark)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount benchmark ${discount.benchmark} is not valid`);
+    }
+    const start = discount.time_ms_start ?? Date.now();
+    if (discount.time_ms_end < start) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount time_ms_end ${discount.time_ms_end} is not valid`);
+    }
+    if (discount.discount_value != null &&
+        !(0, common_js_1.isValidU64)(discount.discount_value)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount discount_value ${discount.discount_value} is not valid`);
+    }
+    (0, util_js_1.validObjects)([service, permission, passport, ...recipient]);
+    if (!(0, common_js_1.IsValidArgType)(service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Discount service type ${service_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("discount_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.string(discount.name),
+                tx.pure.u8(discount.discount_type),
+                tx.pure.u64(discount.discount_value),
+                tx.pure.option("u64", discount.benchmark ?? null),
+                tx.pure.bool(discount.transferable),
+                tx.pure.option("u64", discount.time_ms_start ?? null),
+                tx.pure.u64(discount.time_ms_end),
+                tx.pure.u16(discount.count),
+                tx.pure.vector("address", recipient),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.serviceFn)("discount"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, service),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.string(discount.name),
+                tx.pure.u8(discount.discount_type),
+                tx.pure.u64(discount.discount_value),
+                tx.pure.option("u64", discount.benchmark ?? null),
+                tx.pure.bool(discount.transferable),
+                tx.pure.option("u64", discount.time_ms_start ?? null),
+                tx.pure.u64(discount.time_ms_end),
+                tx.pure.u16(discount.count),
+                tx.pure.vector("address", recipient),
+                tx.object.clock(),
+            ],
+            typeArguments: [service_type],
+        });
+    }
 }
+//# sourceMappingURL=service.js.map