wowok 2.1.13 → 2.1.15

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

@@ -1,45 +1,20 @@
-"use strict";
 // Copyright (c) Wowok.
 // SPDX-License-Identifier: Apache-2.0
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_VOTING_GUARD_COUNT = exports.CallArbitration = void 0;
-exports.create = create;
-exports.newArbitration = newArbitration;
-exports.description_set = description_set;
-exports.location_set = location_set;
-exports.voting_guard_add = voting_guard_add;
-exports.voting_guard_remove = voting_guard_remove;
-exports.voting_guard_clear = voting_guard_clear;
-exports.usage_guard_set = usage_guard_set;
-exports.usage_guard_none = usage_guard_none;
-exports.pause = pause;
-exports.fee_set = fee_set;
-exports.dispute = dispute;
-exports.vote = vote;
-exports.arbitration = arbitration;
-exports.feedback = feedback;
-exports.confirm = confirm;
-exports.voting_deadline_change = voting_deadline_change;
-exports.reset = reset;
-exports.arb_withdraw = arb_withdraw;
-exports.fees_alloc = fees_alloc;
-exports.fees_transfer = fees_transfer;
-exports.um_set = um_set;
-const common_js_1 = require("../common.js");
-const exception_js_1 = require("../exception.js");
-const local_js_1 = require("../local/local.js");
-const object_js_1 = require("../query/object.js");
-const util_js_1 = require("../util.js");
-const base_js_1 = require("./base.js");
-const permission_js_1 = require("./permission.js");
-const sui_types_js_1 = require("../../utils/sui-types.js");
-const arb_js_1 = require("./arb.js");
-const arb_js_2 = require("./arb.js");
-const permission_js_2 = require("./permission.js");
-const received_js_1 = require("../query/received.js");
+import { toTxObject, isValidDescription, MAX_DESCRIPTION_LENGTH, PackageAddress, isValidU8, isValidU64, GetObjectExisted, GetObject, IsValidArgType, isValidLongName, MAX_LONG_NAME_LENGTH, isValidU32, isValidArray, GetObjectDescription, arbitrationFn, } from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { LocalMark } from "../local/local.js";
+import { ObjectType } from "../query/object.js";
+import { owner_receive, parseObjectType, validObjects } from "../util.js";
+import { CallBase, getCoinParam } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { isValidWowAddress } from "../../utils/sui-types.js";
+import { MAX_PROPOSITION_COUNT } from "./arb.js";
+import { create as arbCreate } from "./arb.js";
+import { create as permissionCreate } from "./permission.js";
+import { query_received } from "../query/received.js";
 // ================================================
 // 数据操作类
-class CallArbitration extends base_js_1.CallBase {
+export class CallArbitration extends CallBase {
     data;
     object_address = undefined;
     permission_address = undefined;
@@ -52,28 +27,28 @@ class CallArbitration extends base_js_1.CallBase {
     async prepare(env) {
         await super.prepare(env);
         if (!this.object_address) {
-            this.object_address = await (0, common_js_1.GetObjectExisted)(this.data?.object);
+            this.object_address = await GetObjectExisted(this.data?.object);
         }
         if (this.object_address) {
-            await this.update_content(env, object_js_1.ObjectType.Arbitration, this.object_address);
+            await this.update_content(env, ObjectType.Arbitration, this.object_address);
             if (!this.content)
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.object:" + this.object_address);
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.object:" + this.object_address);
             this.permission_address = this.content.permission;
-            this.parameter_type = (0, util_js_1.parseObjectType)(this.content.type_raw, "arbitration::Arbitration");
+            this.parameter_type = parseObjectType(this.content.type_raw, "arbitration::Arbitration");
             if (!this.permission_address) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.object.permission is empty");
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.object.permission is empty");
             }
-            if (!(0, common_js_1.IsValidArgType)(this.parameter_type)) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, "CallArbitration_Data.data.object.type_parameter is empty");
+            if (!IsValidArgType(this.parameter_type)) {
+                W_ERROR(WErrors.IsValidArgType, "CallArbitration_Data.data.object.type_parameter is empty");
             }
         }
         else {
-            const n = (0, common_js_1.GetObject)(this.data.object);
-            this.permission_address = await (0, common_js_1.GetObjectExisted)(n?.permission);
-            this.new_permission_description = (0, common_js_1.GetObjectDescription)(n);
+            const n = GetObject(this.data.object);
+            this.permission_address = await GetObjectExisted(n?.permission);
+            this.new_permission_description = GetObjectDescription(n);
             this.parameter_type = n?.type_parameter;
-            if (!(0, common_js_1.IsValidArgType)(this.parameter_type)) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, "CallArbitration_Data.data.object.type_parameter invalid");
+            if (!IsValidArgType(this.parameter_type)) {
+                W_ERROR(WErrors.IsValidArgType, "CallArbitration_Data.data.object.type_parameter invalid");
             }
         }
     }
@@ -93,11 +68,11 @@ class CallArbitration extends base_js_1.CallBase {
         };
         const obj = this.content;
         if (this.permission_address && !this.object_address) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_NEW);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_NEW);
         }
         if (this.data?.dispute != null) {
             if (obj.bPaused) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "Arbitration is paused and cannot be disputed");
+                W_ERROR(WErrors.InvalidParam, "Arbitration is paused and cannot be disputed");
             }
             if (obj.usage_guard) {
                 add_guard(obj.usage_guard);
@@ -106,75 +81,75 @@ class CallArbitration extends base_js_1.CallBase {
         if (this.permission_address &&
             this.data?.description != null &&
             this.object_address) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_DESCRIPTION);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_DESCRIPTION);
         }
         if (this.permission_address && this.data?.location != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_LOCATION);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_LOCATION);
         }
         if (this.permission_address && this.data?.fee != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEE);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_FEE);
         }
         if (this.permission_address && this.data?.usage_guard !== undefined) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_USAGE_GUARD);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_USAGE_GUARD);
         }
         if (this.permission_address && this.data?.vote != null) {
             this.data.vote.voting_guard =
-                await local_js_1.LocalMark.Instance().get_address(this.data.vote.voting_guard);
+                await LocalMark.Instance().get_address(this.data.vote.voting_guard);
             if (this.data.vote.voting_guard) {
                 add_guard(this.data.vote.voting_guard);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallArbitration_Data.data.vote.voting_guard ${this.data.vote.voting_guard} invalid`);
+                W_ERROR(WErrors.InvalidParam, `CallArbitration_Data.data.vote.voting_guard ${this.data.vote.voting_guard} invalid`);
             }
         }
         if (this.permission_address && this.data?.voting_guard != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_VOTING_GUARD);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_VOTING_GUARD);
         }
         if (this.permission_address && this.data?.pause !== undefined) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_PAUSE);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_PAUSE);
         }
         if (this.permission_address && this.data?.owner_receive != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_OWNER_RECEIVE);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_OWNER_RECEIVE);
         }
         // 处理 arbitration 操作权限
         if (this.permission_address && this.data?.arbitration != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_ARBITRATION);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_ARBITRATION);
         }
         // 处理 feedback 操作权限
         if (this.permission_address && this.data?.feedback != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEEDBACK);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_FEEDBACK);
         }
         // 处理 confirm 操作权限
         if (this.permission_address && this.data?.confirm != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_CONFIRM);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_CONFIRM);
         }
         // 处理 voting_deadline_change 操作权限
         if (this.permission_address &&
             this.data?.voting_deadline_change != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_VOTING_DEADLINE_CHANGE);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_VOTING_DEADLINE_CHANGE);
         }
         // 处理 reset 操作权限
         if (this.permission_address && this.data?.reset != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_RESET);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_RESET);
         }
         // 处理 arb_withdraw 操作权限
         if (this.permission_address && this.data?.arb_withdraw != null) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_ARB_WITHDRAW);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_ARB_WITHDRAW);
         }
         // 处理 fees_alloc 操作权限
         if (this.permission_address && this.data?.fees_transfer != null) {
             if ("allocator" in this.data.fees_transfer.to) {
-                add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEES_ALLOC);
+                add_perm(BuiltinPermissionIndex.ARBITRATION_FEES_ALLOC);
             }
             else if ("treasury" in this.data.fees_transfer.to) {
-                add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEES_TRANSFER);
+                add_perm(BuiltinPermissionIndex.ARBITRATION_FEES_TRANSFER);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.fees_withdraw.to is invalid");
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.fees_withdraw.to is invalid");
             }
         }
         if (this.permission_address && this.data.um !== undefined) {
-            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_UM);
+            add_perm(BuiltinPermissionIndex.ARBITRATION_UM);
         }
         if (this.permission_address || guards.length > 0) {
             return await this.check_permission_and_call(env, this.permission_address, perms, guards);
@@ -186,23 +161,23 @@ class CallArbitration extends base_js_1.CallBase {
         let object = this.object_address;
         if (!this.object_address) {
             if (!permission) {
-                permission = (0, permission_js_1.newPermission)(tx, this.new_permission_description ?? "");
+                permission = newPermission(tx, this.new_permission_description ?? "");
             }
             if (permission && this.parameter_type) {
                 object = newArbitration(tx, this.parameter_type, permission, this.data?.description ?? "", passport);
             }
         }
         if (!object || !permission) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.object:" + this.object_address);
+            W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.object:" + this.object_address);
         }
         if (this.data.dispute != null) {
-            const order = await local_js_1.LocalMark.Instance().get_address(this.data.dispute.order);
+            const order = await LocalMark.Instance().get_address(this.data.dispute.order);
             if (!order) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.dispute.order:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.dispute.order:" +
                     this.data.dispute.order);
             }
             const arb = await dispute(env, tx, object, this.parameter_type, order, this.data.dispute.description, this.data.dispute.proposition, this.data.dispute.fee, passport);
-            await this.new_with_mark(env, tx, object_js_1.ObjectType.Arb, (0, arb_js_2.create)(tx, arb, this.parameter_type), (0, common_js_1.GetObject)(this.data?.dispute.namedArb));
+            await this.new_with_mark(env, tx, ObjectType.Arb, arbCreate(tx, arb, this.parameter_type), GetObject(this.data?.dispute.namedArb));
         }
         // 处理 description 更新
         if (this.data.description != null && this.object_address) {
@@ -222,76 +197,76 @@ class CallArbitration extends base_js_1.CallBase {
         }
         // 处理 confirm 操作
         if (this.data.confirm != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.confirm.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.confirm.arb);
             if (arb) {
                 confirm(tx, object, this.parameter_type, permission, arb, this.data.confirm.voting_deadline, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.confirm.arb:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.confirm.arb:" +
                     this.data.confirm.arb);
             }
         }
         // 处理 voting_deadline_change 操作
         if (this.data.voting_deadline_change != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.voting_deadline_change.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.voting_deadline_change.arb);
             if (arb) {
                 voting_deadline_change(tx, object, this.parameter_type, permission, arb, this.data.voting_deadline_change.voting_deadline, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.voting_deadline_change.arb:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.voting_deadline_change.arb:" +
                     this.data.voting_deadline_change.arb);
             }
         }
         if (this.data.vote != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.vote.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.vote.arb);
             if (arb) {
                 vote(tx, object, this.parameter_type, permission, arb, this.data.vote.votes, this.data.vote.voting_guard, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.vote.arb:" + this.data.vote.arb);
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.vote.arb:" + this.data.vote.arb);
             }
         }
         // 处理 feedback 操作
         if (this.data.feedback != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.feedback.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.feedback.arb);
             if (arb) {
                 feedback(tx, object, this.parameter_type, permission, arb, this.data.feedback.feedback, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.feedback.arb:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.feedback.arb:" +
                     this.data.feedback.arb);
             }
         }
         // 处理 arbitration 操作
         if (this.data.arbitration != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.arbitration.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.arbitration.arb);
             if (arb) {
                 arbitration(tx, object, this.parameter_type, permission, arb, this.data.arbitration.feedback, this.data.arbitration.indemnity, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.arbitration.arb:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.arbitration.arb:" +
                     this.data.arbitration.arb);
             }
         }
         // 处理 reset 操作
         if (this.data.reset != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.reset.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.reset.arb);
             if (arb) {
                 reset(tx, object, this.parameter_type, permission, arb, this.data.reset.feedback, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.reset.arb:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.reset.arb:" +
                     this.data.reset.arb);
             }
         }
         // 处理 arb_withdraw 操作
         if (this.data.arb_withdraw != null) {
-            const arb = await local_js_1.LocalMark.Instance().get_address(this.data.arb_withdraw.arb);
+            const arb = await LocalMark.Instance().get_address(this.data.arb_withdraw.arb);
             if (arb) {
                 arb_withdraw(tx, object, this.parameter_type, permission, arb, passport);
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.arb_withdraw.arb:" +
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.arb_withdraw.arb:" +
                     this.data.arb_withdraw.arb);
             }
         }
@@ -299,36 +274,36 @@ class CallArbitration extends base_js_1.CallBase {
         if (this.data.fees_transfer != null) {
             let payment_address = undefined;
             if ("allocation" in this.data.fees_transfer.to) {
-                const a = await local_js_1.LocalMark.Instance().get_address(this.data.fees_transfer.to.allocation);
+                const a = await LocalMark.Instance().get_address(this.data.fees_transfer.to.allocation);
                 if (a) {
                     payment_address = fees_alloc(tx, object, this.parameter_type, permission, a, this.data.fees_transfer.payment_remark, this.data.fees_transfer.payment_index);
                 }
                 else {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.fees_transfer.to.allocation:" +
+                    W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.fees_transfer.to.allocation:" +
                         this.data.fees_transfer.to.allocation);
                 }
             }
             else if ("treasury" in this.data.fees_transfer.to) {
-                const t = await local_js_1.LocalMark.Instance().get_address(this.data.fees_transfer.to.treasury);
+                const t = await LocalMark.Instance().get_address(this.data.fees_transfer.to.treasury);
                 if (t) {
                     payment_address = fees_transfer(tx, object, this.parameter_type, permission, t, this.data.fees_transfer.payment_remark, this.data.fees_transfer.payment_index, passport);
                 }
                 else {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.fees_transfer.to.treasury:" +
+                    W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.fees_transfer.to.treasury:" +
                         this.data.fees_transfer.to.treasury);
                 }
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.fees_withdraw.to is invalid");
+                W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.fees_withdraw.to is invalid");
             }
             if (this.data.fees_transfer.newPayment != null && payment_address) {
-                await this.new_with_mark(env, tx, object_js_1.ObjectType.Payment, payment_address, this.data.fees_transfer.newPayment);
+                await this.new_with_mark(env, tx, ObjectType.Payment, payment_address, this.data.fees_transfer.newPayment);
             }
         }
         // 处理 usage_guard 更新
         if (this.data.usage_guard !== undefined) {
             if (this.data.usage_guard) {
-                const guard = await local_js_1.LocalMark.Instance().get_address(this.data.usage_guard);
+                const guard = await LocalMark.Instance().get_address(this.data.usage_guard);
                 if (guard) {
                     usage_guard_set(tx, object, this.parameter_type, permission, guard, passport);
                 }
@@ -343,14 +318,14 @@ class CallArbitration extends base_js_1.CallBase {
                 case "add":
                 case "set": {
                     if (this.data.voting_guard.guards.length >
-                        exports.MAX_VOTING_GUARD_COUNT) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting guard count exceeds maximum count ${exports.MAX_VOTING_GUARD_COUNT}`);
+                        MAX_VOTING_GUARD_COUNT) {
+                        W_ERROR(WErrors.InvalidParam, `Voting guard count exceeds maximum count ${MAX_VOTING_GUARD_COUNT}`);
                     }
                     if (this.data.voting_guard.op === "set") {
                         voting_guard_clear(tx, object, this.parameter_type, permission, passport);
                     }
                     const guards = await Promise.all(this.data.voting_guard.guards.map(async (vg) => {
-                        const guard = await local_js_1.LocalMark.Instance().get_address(vg.guard);
+                        const guard = await LocalMark.Instance().get_address(vg.guard);
                         return {
                             originalGuard: vg.guard,
                             guard,
@@ -361,7 +336,7 @@ class CallArbitration extends base_js_1.CallBase {
                         .filter((vg) => vg.guard === undefined)
                         .map((vg) => vg.originalGuard);
                     if (invalidGuards.length > 0) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Invalid voting guards: ${invalidGuards.join(", ")} could not be resolved to valid addresses`);
+                        W_ERROR(WErrors.InvalidParam, `Invalid voting guards: ${invalidGuards.join(", ")} could not be resolved to valid addresses`);
                     }
                     const voting_guards = guards.map((vg) => ({
                         guard: vg.guard,
@@ -371,9 +346,9 @@ class CallArbitration extends base_js_1.CallBase {
                     break;
                 }
                 case "remove": {
-                    const guards = await local_js_1.LocalMark.Instance().get_many_address_availables(this.data.voting_guard.guards);
-                    if (guards.length > exports.MAX_VOTING_GUARD_COUNT) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting guard count exceeds maximum count ${exports.MAX_VOTING_GUARD_COUNT}`);
+                    const guards = await LocalMark.Instance().get_many_address_availables(this.data.voting_guard.guards);
+                    if (guards.length > MAX_VOTING_GUARD_COUNT) {
+                        W_ERROR(WErrors.InvalidParam, `Voting guard count exceeds maximum count ${MAX_VOTING_GUARD_COUNT}`);
                     }
                     voting_guard_remove(tx, object, this.parameter_type, permission, guards, passport);
                     break;
@@ -388,65 +363,64 @@ class CallArbitration extends base_js_1.CallBase {
         if (this.data.owner_receive != null && this.object_address) {
             // 直接传递整个ReceivedObjects参数给owner_receive函数
             if (this.data.owner_receive === "recently") {
-                this.data.owner_receive = await (0, received_js_1.query_received)({
+                this.data.owner_receive = await query_received({
                     object: this.object_address,
                     all_type: true,
                     no_cache: env.no_cache,
                     network: env.network,
                 });
             }
-            await (0, util_js_1.owner_receive)(tx, object, permission, this.data.owner_receive, this.parameter_type, (name) => `${common_js_1.PackageAddress}::arbitration::${name}`, passport);
+            await owner_receive(tx, object, permission, this.data.owner_receive, this.parameter_type, (name) => `${PackageAddress}::arbitration::${name}`, passport);
         }
         // 处理 um
         if (this.data.um !== undefined) {
             let um_address = null;
             if (this.data.um) {
                 um_address =
-                    (await local_js_1.LocalMark.Instance().get_address(this.data.um)) ||
+                    (await LocalMark.Instance().get_address(this.data.um)) ||
                         null;
                 if (!um_address) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallArbitration_Data.data.um:" + this.data.um);
+                    W_ERROR(WErrors.InvalidParam, "CallArbitration_Data.data.um:" + this.data.um);
                 }
             }
             um_set(tx, object, this.parameter_type, permission, um_address, passport);
         }
         if (!this.permission_address) {
-            const p = (0, common_js_1.GetObject)(this.data?.object);
-            await this.new_with_mark(env, tx, object_js_1.ObjectType.Permission, (0, permission_js_2.create)(tx, permission), (0, common_js_1.GetObject)(p.permission));
+            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, object_js_1.ObjectType.Arbitration, create(tx, object, this.parameter_type), (0, common_js_1.GetObject)(this.data?.object));
+            await this.new_with_mark(env, tx, ObjectType.Arbitration, create(tx, object, this.parameter_type), GetObject(this.data?.object));
         }
     }
 }
-exports.CallArbitration = CallArbitration;
 // ================================================
 // move 调用函数
-exports.MAX_VOTING_GUARD_COUNT = 50;
-function create(tx, arbitration, parameter_type) {
-    (0, util_js_1.validObjects)([arbitration]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export const MAX_VOTING_GUARD_COUNT = 50;
+export function create(tx, arbitration, parameter_type) {
+    validObjects([arbitration]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     return tx.moveCall({
-        target: (0, common_js_1.arbitrationFn)(`create`),
-        arguments: [(0, common_js_1.toTxObject)(tx, arbitration)],
+        target: arbitrationFn(`create`),
+        arguments: [toTxObject(tx, arbitration)],
         typeArguments: [parameter_type],
     });
 }
-function newArbitration(tx, parameter_type, permission, description, passport) {
-    (0, util_js_1.validObjects)([permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function newArbitration(tx, parameter_type, permission, description, passport) {
+    validObjects([permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(description)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration description ${description} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(description)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration description ${description} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
     if (passport) {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`new_with_passport`),
+            target: arbitrationFn(`new_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, permission),
                 passport,
                 tx.pure.string(description),
                 tx.object.mutRegistrar(),
@@ -457,9 +431,9 @@ function newArbitration(tx, parameter_type, permission, description, passport) {
     }
     else {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`new`),
+            target: arbitrationFn(`new`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, permission),
                 tx.pure.string(description),
                 tx.object.mutRegistrar(),
                 tx.object.clock(),
@@ -468,20 +442,20 @@ function newArbitration(tx, parameter_type, permission, description, passport) {
         });
     }
 }
-function description_set(tx, arbitration, parameter_type, permission, description, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function description_set(tx, arbitration, parameter_type, permission, description, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(description)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration description ${description} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(description)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration description ${description} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`description_set_with_passsport`),
+            target: arbitrationFn(`description_set_with_passsport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.pure.string(description),
             ],
@@ -490,30 +464,30 @@ function description_set(tx, arbitration, parameter_type, permission, descriptio
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`description_set`),
+            target: arbitrationFn(`description_set`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.pure.string(description),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function location_set(tx, arbitration, parameter_type, permission, location, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function location_set(tx, arbitration, parameter_type, permission, location, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidLongName)(location)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration location ${location} is exceeds maximum length ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    if (!isValidLongName(location)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration location ${location} is exceeds maximum length ${MAX_LONG_NAME_LENGTH}`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`location_set_with_passport`),
+            target: arbitrationFn(`location_set_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.pure.string(location),
             ],
@@ -522,35 +496,35 @@ function location_set(tx, arbitration, parameter_type, permission, location, pas
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`location_set`),
+            target: arbitrationFn(`location_set`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.pure.string(location),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function voting_guard_add(tx, arbitration, parameter_type, permission, voting_guards, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function voting_guard_add(tx, arbitration, parameter_type, permission, voting_guards, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     voting_guards.forEach((vg) => {
-        if (!(0, sui_types_js_1.isValidWowAddress)(vg.guard)) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting guard ${vg.guard} is not valid`);
+        if (!isValidWowAddress(vg.guard)) {
+            W_ERROR(WErrors.InvalidParam, `Voting guard ${vg.guard} is not valid`);
         }
         if ("GuardIdentifier" in vg.vote_weight) {
-            if (!(0, common_js_1.isValidU8)(vg.vote_weight.GuardIdentifier)) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting guard ${vg.vote_weight.GuardIdentifier} must be u8 number`);
+            if (!isValidU8(vg.vote_weight.GuardIdentifier)) {
+                W_ERROR(WErrors.InvalidParam, `Voting guard ${vg.vote_weight.GuardIdentifier} must be u8 number`);
             }
             if (passport) {
                 tx.moveCall({
-                    target: (0, common_js_1.arbitrationFn)(`voting_guard_add_by_id_add_with_passport`),
+                    target: arbitrationFn(`voting_guard_add_by_id_add_with_passport`),
                     arguments: [
-                        (0, common_js_1.toTxObject)(tx, arbitration),
-                        (0, common_js_1.toTxObject)(tx, permission),
+                        toTxObject(tx, arbitration),
+                        toTxObject(tx, permission),
                         passport,
                         tx.object(vg.guard),
                         tx.pure.u8(vg.vote_weight.GuardIdentifier),
@@ -560,10 +534,10 @@ function voting_guard_add(tx, arbitration, parameter_type, permission, voting_gu
             }
             else {
                 tx.moveCall({
-                    target: (0, common_js_1.arbitrationFn)(`voting_guard_add_by_id_add`),
+                    target: arbitrationFn(`voting_guard_add_by_id_add`),
                     arguments: [
-                        (0, common_js_1.toTxObject)(tx, arbitration),
-                        (0, common_js_1.toTxObject)(tx, permission),
+                        toTxObject(tx, arbitration),
+                        toTxObject(tx, permission),
                         tx.object(vg.guard),
                         tx.pure.u8(vg.vote_weight.GuardIdentifier),
                     ],
@@ -572,15 +546,15 @@ function voting_guard_add(tx, arbitration, parameter_type, permission, voting_gu
             }
         }
         else if ("FixedValue" in vg.vote_weight) {
-            if (!(0, common_js_1.isValidU32)(vg.vote_weight.FixedValue)) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting guard ${vg.vote_weight.FixedValue} must be u32 number`);
+            if (!isValidU32(vg.vote_weight.FixedValue)) {
+                W_ERROR(WErrors.InvalidParam, `Voting guard ${vg.vote_weight.FixedValue} must be u32 number`);
             }
             if (passport) {
                 tx.moveCall({
-                    target: (0, common_js_1.arbitrationFn)(`voting_guard_fixed_add_with_passport`),
+                    target: arbitrationFn(`voting_guard_fixed_add_with_passport`),
                     arguments: [
-                        (0, common_js_1.toTxObject)(tx, arbitration),
-                        (0, common_js_1.toTxObject)(tx, permission),
+                        toTxObject(tx, arbitration),
+                        toTxObject(tx, permission),
                         passport,
                         tx.object(vg.guard),
                         tx.pure.u32(vg.vote_weight.FixedValue),
@@ -592,10 +566,10 @@ function voting_guard_add(tx, arbitration, parameter_type, permission, voting_gu
             }
             else {
                 tx.moveCall({
-                    target: (0, common_js_1.arbitrationFn)(`voting_guard_fixed_add`),
+                    target: arbitrationFn(`voting_guard_fixed_add`),
                     arguments: [
-                        (0, common_js_1.toTxObject)(tx, arbitration),
-                        (0, common_js_1.toTxObject)(tx, permission),
+                        toTxObject(tx, arbitration),
+                        toTxObject(tx, permission),
                         tx.object(vg.guard),
                         tx.pure.u32(vg.vote_weight.FixedValue),
                         tx.object.mutRegistrar(),
@@ -607,20 +581,20 @@ function voting_guard_add(tx, arbitration, parameter_type, permission, voting_gu
         }
     });
 }
-function voting_guard_remove(tx, arbitration, parameter_type, permission, guards, passport) {
+export function voting_guard_remove(tx, arbitration, parameter_type, permission, guards, passport) {
     if (guards.length === 0) {
         return;
     }
-    (0, util_js_1.validObjects)([arbitration, permission, ...guards]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+    validObjects([arbitration, permission, ...guards]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`voting_guard_remove_with_passport`),
+            target: arbitrationFn(`voting_guard_remove_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.pure.vector("address", guards),
                 tx.object.mutRegistrar(),
@@ -630,10 +604,10 @@ function voting_guard_remove(tx, arbitration, parameter_type, permission, guards
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`voting_guard_remove`),
+            target: arbitrationFn(`voting_guard_remove`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.pure.vector("address", guards),
                 tx.object.mutRegistrar(),
             ],
@@ -641,17 +615,17 @@ function voting_guard_remove(tx, arbitration, parameter_type, permission, guards
         });
     }
 }
-function voting_guard_clear(tx, arbitration, parameter_type, permission, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function voting_guard_clear(tx, arbitration, parameter_type, permission, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`voting_guard_clear_with_passport`),
+            target: arbitrationFn(`voting_guard_clear_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.object.mutRegistrar(),
             ],
@@ -660,27 +634,27 @@ function voting_guard_clear(tx, arbitration, parameter_type, permission, passpor
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`voting_guard_clear`),
+            target: arbitrationFn(`voting_guard_clear`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.object.mutRegistrar(),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function usage_guard_set(tx, arbitration, parameter_type, permission, guard, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, guard]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function usage_guard_set(tx, arbitration, parameter_type, permission, guard, passport) {
+    validObjects([arbitration, permission, guard]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`usage_guard_set_with_passport`),
+            target: arbitrationFn(`usage_guard_set_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.object(guard),
                 tx.object.mutRegistrar(),
@@ -691,10 +665,10 @@ function usage_guard_set(tx, arbitration, parameter_type, permission, guard, pas
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`usage_guard_set`),
+            target: arbitrationFn(`usage_guard_set`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.object(guard),
                 tx.object.mutRegistrar(),
                 tx.object.clock(),
@@ -703,17 +677,17 @@ function usage_guard_set(tx, arbitration, parameter_type, permission, guard, pas
         });
     }
 }
-function usage_guard_none(tx, arbitration, parameter_type, permission, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function usage_guard_none(tx, arbitration, parameter_type, permission, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`usage_guard_none_with_passport`),
+            target: arbitrationFn(`usage_guard_none_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.object.mutRegistrar(),
             ],
@@ -722,27 +696,27 @@ function usage_guard_none(tx, arbitration, parameter_type, permission, passport)
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`usage_guard_none`),
+            target: arbitrationFn(`usage_guard_none`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.object.mutRegistrar(),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function pause(tx, arbitration, parameter_type, permission, pause, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function pause(tx, arbitration, parameter_type, permission, pause, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`pause_with_passport`),
+            target: arbitrationFn(`pause_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.pure.bool(pause),
             ],
@@ -751,30 +725,30 @@ function pause(tx, arbitration, parameter_type, permission, pause, passport) {
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`pause`),
+            target: arbitrationFn(`pause`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.pure.bool(pause),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function fee_set(tx, arbitration, parameter_type, permission, fee, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function fee_set(tx, arbitration, parameter_type, permission, fee, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidU64)(fee)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Fee ${fee} is not valid u64`);
+    if (!isValidU64(fee)) {
+        W_ERROR(WErrors.InvalidParam, `Fee ${fee} is not valid u64`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`fee_set_with_passport`),
+            target: arbitrationFn(`fee_set_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
                 tx.pure.u64(fee),
             ],
@@ -783,38 +757,38 @@ function fee_set(tx, arbitration, parameter_type, permission, fee, passport) {
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`fee_set`),
+            target: arbitrationFn(`fee_set`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 tx.pure.u64(fee),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-async function dispute(env, tx, arbitration, parameter_type, order, description, proposition, fee, passport) {
-    (0, util_js_1.validObjects)([arbitration, order]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export async function dispute(env, tx, arbitration, parameter_type, order, description, proposition, fee, passport) {
+    validObjects([arbitration, order]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(description)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidDescription, `Description exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(description)) {
+        W_ERROR(WErrors.IsValidDescription, `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    if (proposition.length > arb_js_1.MAX_PROPOSITION_COUNT) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Proposition count exceeds maximum count ${arb_js_1.MAX_PROPOSITION_COUNT}`);
+    if (proposition.length > MAX_PROPOSITION_COUNT) {
+        W_ERROR(WErrors.InvalidParam, `Proposition count exceeds maximum count ${MAX_PROPOSITION_COUNT}`);
     }
-    if (!(0, common_js_1.isValidArray)(proposition, common_js_1.isValidLongName)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Proposition ${proposition} is not valid array of string, each string must less than ${common_js_1.MAX_LONG_NAME_LENGTH}`);
+    if (!isValidArray(proposition, isValidLongName)) {
+        W_ERROR(WErrors.InvalidParam, `Proposition ${proposition} is not valid array of string, each string must less than ${MAX_LONG_NAME_LENGTH}`);
     }
-    const c = await (0, base_js_1.getCoinParam)(env, tx, fee, parameter_type);
+    const c = await getCoinParam(env, tx, fee, parameter_type);
     if (passport) {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`dispute_with_passport`),
+            target: arbitrationFn(`dispute_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
+                toTxObject(tx, arbitration),
                 passport,
-                (0, common_js_1.toTxObject)(tx, order),
+                toTxObject(tx, order),
                 tx.pure.string(description),
                 tx.pure.vector("string", proposition),
                 c,
@@ -825,10 +799,10 @@ async function dispute(env, tx, arbitration, parameter_type, order, description,
     }
     else {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`dispute`),
+            target: arbitrationFn(`dispute`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, order),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, order),
                 tx.pure.string(description),
                 tx.pure.vector("string", proposition),
                 c,
@@ -838,24 +812,24 @@ async function dispute(env, tx, arbitration, parameter_type, order, description,
         });
     }
 }
-function vote(tx, arbitration, parameter_type, permission, arb, votes, voting_guard, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb, voting_guard]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function vote(tx, arbitration, parameter_type, permission, arb, votes, voting_guard, passport) {
+    validObjects([arbitration, permission, arb, voting_guard]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidArray)(votes, common_js_1.isValidU8)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Votes ${votes} is not valid array of u8`);
+    if (!isValidArray(votes, isValidU8)) {
+        W_ERROR(WErrors.InvalidParam, `Votes ${votes} is not valid array of u8`);
     }
     if (passport) {
         // voting by voting-guard
         if (voting_guard) {
             tx.moveCall({
-                target: (0, common_js_1.arbitrationFn)(`vote_with_voting_guard`),
+                target: arbitrationFn(`vote_with_voting_guard`),
                 arguments: [
-                    (0, common_js_1.toTxObject)(tx, arbitration),
+                    toTxObject(tx, arbitration),
                     passport,
-                    (0, common_js_1.toTxObject)(tx, arb),
-                    (0, common_js_1.toTxObject)(tx, voting_guard),
+                    toTxObject(tx, arb),
+                    toTxObject(tx, voting_guard),
                     tx.pure.vector("u8", votes),
                     tx.object.clock(),
                 ],
@@ -864,12 +838,12 @@ function vote(tx, arbitration, parameter_type, permission, arb, votes, voting_gu
         }
         else {
             tx.moveCall({
-                target: (0, common_js_1.arbitrationFn)(`vote_with_passport`),
+                target: arbitrationFn(`vote_with_passport`),
                 arguments: [
-                    (0, common_js_1.toTxObject)(tx, arbitration),
-                    (0, common_js_1.toTxObject)(tx, permission),
+                    toTxObject(tx, arbitration),
+                    toTxObject(tx, permission),
                     passport,
-                    (0, common_js_1.toTxObject)(tx, arb),
+                    toTxObject(tx, arb),
                     tx.pure.vector("u8", votes),
                     tx.object.clock(),
                 ],
@@ -879,11 +853,11 @@ function vote(tx, arbitration, parameter_type, permission, arb, votes, voting_gu
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`vote`),
+            target: arbitrationFn(`vote`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.pure.vector("u8", votes),
                 tx.object.clock(),
             ],
@@ -891,25 +865,25 @@ function vote(tx, arbitration, parameter_type, permission, arb, votes, voting_gu
         });
     }
 }
-function arbitration(tx, arbitration, parameter_type, permission, arb, feedback, indemnity, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function arbitration(tx, arbitration, parameter_type, permission, arb, feedback, indemnity, passport) {
+    validObjects([arbitration, permission, arb]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(feedback)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Feedback ${feedback} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(feedback)) {
+        W_ERROR(WErrors.InvalidParam, `Feedback ${feedback} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    if (!(0, common_js_1.isValidU64)(indemnity)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Indemnity ${indemnity} must be u64 number`);
+    if (!isValidU64(indemnity)) {
+        W_ERROR(WErrors.InvalidParam, `Indemnity ${indemnity} must be u64 number`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`arbitration_with_passport`),
+            target: arbitrationFn(`arbitration_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arb),
                 tx.pure.string(feedback),
                 tx.pure.u64(indemnity),
                 tx.object.clock(),
@@ -919,11 +893,11 @@ function arbitration(tx, arbitration, parameter_type, permission, arb, feedback,
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`arbitration`),
+            target: arbitrationFn(`arbitration`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.pure.string(feedback),
                 tx.pure.u64(indemnity),
                 tx.object.clock(),
@@ -932,22 +906,22 @@ function arbitration(tx, arbitration, parameter_type, permission, arb, feedback,
         });
     }
 }
-function feedback(tx, arbitration, parameter_type, permission, arb, feedback, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function feedback(tx, arbitration, parameter_type, permission, arb, feedback, passport) {
+    validObjects([arbitration, permission, arb]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(feedback)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Feedback ${feedback} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(feedback)) {
+        W_ERROR(WErrors.InvalidParam, `Feedback ${feedback} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`feedback_with_passport`),
+            target: arbitrationFn(`feedback_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arb),
                 tx.pure.string(feedback),
             ],
             typeArguments: [parameter_type],
@@ -955,33 +929,33 @@ function feedback(tx, arbitration, parameter_type, permission, arb, feedback, pa
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`feedback`),
+            target: arbitrationFn(`feedback`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.pure.string(feedback),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function confirm(tx, arbitration, parameter_type, permission, arb, voting_deadline, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function confirm(tx, arbitration, parameter_type, permission, arb, voting_deadline, passport) {
+    validObjects([arbitration, permission, arb]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (voting_deadline !== null && !(0, common_js_1.isValidU64)(voting_deadline)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting deadline ${voting_deadline} must be u64 number or null`);
+    if (voting_deadline !== null && !isValidU64(voting_deadline)) {
+        W_ERROR(WErrors.InvalidParam, `Voting deadline ${voting_deadline} must be u64 number or null`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`confirm_with_passport`),
+            target: arbitrationFn(`confirm_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arb),
                 tx.pure.option("u64", voting_deadline),
             ],
             typeArguments: [parameter_type],
@@ -989,33 +963,33 @@ function confirm(tx, arbitration, parameter_type, permission, arb, voting_deadli
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`confirm`),
+            target: arbitrationFn(`confirm`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.pure.option("u64", voting_deadline),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function voting_deadline_change(tx, arbitration, parameter_type, permission, arb, voting_deadline, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function voting_deadline_change(tx, arbitration, parameter_type, permission, arb, voting_deadline, passport) {
+    validObjects([arbitration, permission, arb]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (voting_deadline !== null && !(0, common_js_1.isValidU64)(voting_deadline)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Voting deadline ${voting_deadline} must be u64 number or null`);
+    if (voting_deadline !== null && !isValidU64(voting_deadline)) {
+        W_ERROR(WErrors.InvalidParam, `Voting deadline ${voting_deadline} must be u64 number or null`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`voting_deadline_change_with_passport`),
+            target: arbitrationFn(`voting_deadline_change_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arb),
                 tx.pure.option("u64", voting_deadline),
             ],
             typeArguments: [parameter_type],
@@ -1023,33 +997,33 @@ function voting_deadline_change(tx, arbitration, parameter_type, permission, arb
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`voting_deadline_change`),
+            target: arbitrationFn(`voting_deadline_change`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.pure.option("u64", voting_deadline),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function reset(tx, arbitration, parameter_type, permission, arb, feedback, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function reset(tx, arbitration, parameter_type, permission, arb, feedback, passport) {
+    validObjects([arbitration, permission, arb]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(feedback)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Feedback ${feedback} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(feedback)) {
+        W_ERROR(WErrors.InvalidParam, `Feedback ${feedback} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`reset_with_passport`),
+            target: arbitrationFn(`reset_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arb),
                 tx.pure.string(feedback),
             ],
             typeArguments: [parameter_type],
@@ -1057,30 +1031,30 @@ function reset(tx, arbitration, parameter_type, permission, arb, feedback, passp
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`reset`),
+            target: arbitrationFn(`reset`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.pure.string(feedback),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function arb_withdraw(tx, arbitration, parameter_type, permission, arb, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, arb]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function arb_withdraw(tx, arbitration, parameter_type, permission, arb, passport) {
+    validObjects([arbitration, permission, arb]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (passport) {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`arb_withdraw_with_passport`),
+            target: arbitrationFn(`arb_withdraw_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arb),
                 tx.object.clock(),
             ],
             typeArguments: [parameter_type],
@@ -1088,36 +1062,36 @@ function arb_withdraw(tx, arbitration, parameter_type, permission, arb, passport
     }
     else {
         tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`arb_withdraw`),
+            target: arbitrationFn(`arb_withdraw`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, arb),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, arb),
                 tx.object.clock(),
             ],
             typeArguments: [parameter_type],
         });
     }
 }
-function fees_alloc(tx, arbitration, parameter_type, permission, allocation, payment_remark, payment_index, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, allocation]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function fees_alloc(tx, arbitration, parameter_type, permission, allocation, payment_remark, payment_index, passport) {
+    validObjects([arbitration, permission, allocation]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(payment_remark)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Payment remark ${payment_remark} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(payment_remark)) {
+        W_ERROR(WErrors.InvalidParam, `Payment remark ${payment_remark} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    if (!(0, common_js_1.isValidU64)(payment_index)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Payment index ${payment_index} must be u64 number`);
+    if (!isValidU64(payment_index)) {
+        W_ERROR(WErrors.InvalidParam, `Payment index ${payment_index} must be u64 number`);
     }
     if (passport) {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`fees_alloc_with_passport`),
+            target: arbitrationFn(`fees_alloc_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, allocation),
+                toTxObject(tx, allocation),
                 tx.pure.string(payment_remark),
                 tx.pure.u64(payment_index),
                 tx.object.mutRegistrar(),
@@ -1128,11 +1102,11 @@ function fees_alloc(tx, arbitration, parameter_type, permission, allocation, pay
     }
     else {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`fees_alloc`),
+            target: arbitrationFn(`fees_alloc`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, allocation),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, allocation),
                 tx.pure.string(payment_remark),
                 tx.pure.u64(payment_index),
                 tx.object.mutRegistrar(),
@@ -1142,25 +1116,25 @@ function fees_alloc(tx, arbitration, parameter_type, permission, allocation, pay
         });
     }
 }
-function fees_transfer(tx, arbitration, parameter_type, permission, treasury, payment_remark, payment_index, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission, treasury]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function fees_transfer(tx, arbitration, parameter_type, permission, treasury, payment_remark, payment_index, passport) {
+    validObjects([arbitration, permission, treasury]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
-    if (!(0, common_js_1.isValidDescription)(payment_remark)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Payment remark ${payment_remark} exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+    if (!isValidDescription(payment_remark)) {
+        W_ERROR(WErrors.InvalidParam, `Payment remark ${payment_remark} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    if (!(0, common_js_1.isValidU64)(payment_index)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Payment index ${payment_index} must be u64 number`);
+    if (!isValidU64(payment_index)) {
+        W_ERROR(WErrors.InvalidParam, `Payment index ${payment_index} must be u64 number`);
     }
     if (passport) {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`fees_transfer_with_passport`),
+            target: arbitrationFn(`fees_transfer_with_passport`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
                 passport,
-                (0, common_js_1.toTxObject)(tx, treasury),
+                toTxObject(tx, treasury),
                 tx.pure.string(payment_remark),
                 tx.pure.u64(payment_index),
                 tx.object.mutRegistrar(),
@@ -1171,11 +1145,11 @@ function fees_transfer(tx, arbitration, parameter_type, permission, treasury, pa
     }
     else {
         return tx.moveCall({
-            target: (0, common_js_1.arbitrationFn)(`fees_transfer`),
+            target: arbitrationFn(`fees_transfer`),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, arbitration),
-                (0, common_js_1.toTxObject)(tx, permission),
-                (0, common_js_1.toTxObject)(tx, treasury),
+                toTxObject(tx, arbitration),
+                toTxObject(tx, permission),
+                toTxObject(tx, treasury),
                 tx.pure.string(payment_remark),
                 tx.pure.u64(payment_index),
                 tx.object.mutRegistrar(),
@@ -1185,20 +1159,20 @@ function fees_transfer(tx, arbitration, parameter_type, permission, treasury, pa
         });
     }
 }
-function um_set(tx, arbitration, parameter_type, permission, um, passport) {
-    (0, util_js_1.validObjects)([arbitration, permission]);
-    if (!(0, common_js_1.IsValidArgType)(parameter_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
+export function um_set(tx, arbitration, parameter_type, permission, um, passport) {
+    validObjects([arbitration, permission]);
+    if (!IsValidArgType(parameter_type)) {
+        W_ERROR(WErrors.InvalidParam, `Arbitration type ${parameter_type} is not valid`);
     }
     if (um) {
         if (passport) {
             tx.moveCall({
-                target: (0, common_js_1.arbitrationFn)(`um_set_with_passport`),
+                target: arbitrationFn(`um_set_with_passport`),
                 arguments: [
-                    (0, common_js_1.toTxObject)(tx, arbitration),
-                    (0, common_js_1.toTxObject)(tx, permission),
+                    toTxObject(tx, arbitration),
+                    toTxObject(tx, permission),
                     passport,
-                    (0, common_js_1.toTxObject)(tx, um),
+                    toTxObject(tx, um),
                     tx.object.mutRegistrar(),
                     tx.object.clock(),
                 ],
@@ -1207,11 +1181,11 @@ function um_set(tx, arbitration, parameter_type, permission, um, passport) {
         }
         else {
             tx.moveCall({
-                target: (0, common_js_1.arbitrationFn)(`um_set`),
+                target: arbitrationFn(`um_set`),
                 arguments: [
-                    (0, common_js_1.toTxObject)(tx, arbitration),
-                    (0, common_js_1.toTxObject)(tx, permission),
-                    (0, common_js_1.toTxObject)(tx, um),
+                    toTxObject(tx, arbitration),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, um),
                     tx.object.mutRegistrar(),
                     tx.object.clock(),
                 ],
@@ -1222,10 +1196,10 @@ function um_set(tx, arbitration, parameter_type, permission, um, passport) {
     else {
         if (passport) {
             tx.moveCall({
-                target: (0, common_js_1.arbitrationFn)(`um_none_with_passport`),
+                target: arbitrationFn(`um_none_with_passport`),
                 arguments: [
-                    (0, common_js_1.toTxObject)(tx, arbitration),
-                    (0, common_js_1.toTxObject)(tx, permission),
+                    toTxObject(tx, arbitration),
+                    toTxObject(tx, permission),
                     passport,
                     tx.object.mutRegistrar(),
                 ],
@@ -1234,10 +1208,10 @@ function um_set(tx, arbitration, parameter_type, permission, um, passport) {
         }
         else {
             tx.moveCall({
-                target: (0, common_js_1.arbitrationFn)(`um_none`),
+                target: arbitrationFn(`um_none`),
                 arguments: [
-                    (0, common_js_1.toTxObject)(tx, arbitration),
-                    (0, common_js_1.toTxObject)(tx, permission),
+                    toTxObject(tx, arbitration),
+                    toTxObject(tx, permission),
                     tx.object.mutRegistrar(),
                 ],
                 typeArguments: [parameter_type],