wowok 2.1.9 → 2.1.12

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

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