wowok 2.1.10 → 2.1.13

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

@@ -1,1623 +1,1248 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var arbitration_exports = {};
-__export(arbitration_exports, {
-  CallArbitration: () => CallArbitration,
-  MAX_VOTING_GUARD_COUNT: () => MAX_VOTING_GUARD_COUNT,
-  arb_withdraw: () => arb_withdraw,
-  arbitration: () => arbitration,
-  confirm: () => confirm,
-  create: () => create,
-  description_set: () => description_set,
-  dispute: () => dispute,
-  fee_set: () => fee_set,
-  feedback: () => feedback,
-  fees_alloc: () => fees_alloc,
-  fees_transfer: () => fees_transfer,
-  location_set: () => location_set,
-  newArbitration: () => newArbitration,
-  pause: () => pause,
-  reset: () => reset,
-  um_set: () => um_set,
-  usage_guard_none: () => usage_guard_none,
-  usage_guard_set: () => usage_guard_set,
-  vote: () => vote,
-  voting_deadline_change: () => voting_deadline_change,
-  voting_guard_add: () => voting_guard_add,
-  voting_guard_clear: () => voting_guard_clear,
-  voting_guard_remove: () => voting_guard_remove
-});
-module.exports = __toCommonJS(arbitration_exports);
-var import_common = require("../common.js");
-var import_exception = require("../exception.js");
-var import_local = require("../local/local.js");
-var import_object = require("../query/object.js");
-var import_util = require("../util.js");
-var import_base = require("./base.js");
-var import_permission = require("./permission.js");
-var import_sui_types = require("../../utils/sui-types.js");
-var import_arb = require("./arb.js");
-var import_arb2 = require("./arb.js");
-var import_permission2 = require("./permission.js");
-var import_received = require("../query/received.js");
-class CallArbitration extends import_base.CallBase {
-  constructor(data) {
-    super();
-    __publicField(this, "data");
-    __publicField(this, "object_address");
-    __publicField(this, "permission_address");
-    __publicField(this, "new_permission_description");
-    __publicField(this, "parameter_type");
-    this.data = data;
-  }
-  async prepare(env) {
-    await super.prepare(env);
-    if (!this.object_address) {
-      this.object_address = await (0, import_common.GetObjectExisted)(this.data?.object);
-    }
-    if (this.object_address) {
-      await this.update_content(
-        env,
-        import_object.ObjectType.Arbitration,
-        this.object_address
-      );
-      if (!this.content)
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.object:" + this.object_address
-        );
-      this.permission_address = this.content.permission;
-      this.parameter_type = (0, import_util.parseObjectType)(
-        this.content.type_raw,
-        "arbitration::Arbitration"
-      );
-      if (!this.permission_address) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.object.permission is empty"
-        );
-      }
-      if (!(0, import_common.IsValidArgType)(this.parameter_type)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidArgType,
-          "CallArbitration_Data.data.object.type_parameter is empty"
-        );
-      }
-    } else {
-      const n = (0, import_common.GetObject)(
-        this.data.object
-      );
-      this.permission_address = await (0, import_common.GetObjectExisted)(n?.permission);
-      this.new_permission_description = (0, import_common.GetObjectDescription)(n);
-      this.parameter_type = n?.type_parameter;
-      if (!(0, import_common.IsValidArgType)(this.parameter_type)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidArgType,
-          "CallArbitration_Data.data.object.type_parameter invalid"
-        );
-      }
-    }
-  }
-  async call(env) {
-    await this.prepare(env);
-    const guards = [];
-    const perms = [];
-    const add_guard = (guard) => {
-      if (!guards.includes(guard)) {
-        guards.push(guard);
-      }
-    };
-    const add_perm = (index) => {
-      if (this.permission_address && !perms.includes(index)) {
-        perms.push(index);
-      }
-    };
-    const obj = this.content;
-    if (this.permission_address && !this.object_address) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_NEW);
-    }
-    if (this.data?.dispute != null) {
-      if (obj.bPaused) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "Arbitration is paused and cannot be disputed"
-        );
-      }
-      if (obj.usage_guard) {
-        add_guard(obj.usage_guard);
-      }
-    }
-    if (this.permission_address && this.data?.description != null && this.object_address) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_DESCRIPTION);
-    }
-    if (this.permission_address && this.data?.location != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_LOCATION);
-    }
-    if (this.permission_address && this.data?.fee != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_FEE);
-    }
-    if (this.permission_address && this.data?.usage_guard !== void 0) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_USAGE_GUARD);
-    }
-    if (this.permission_address && this.data?.vote != null) {
-      this.data.vote.voting_guard = await import_local.LocalMark.Instance().get_address(
-        this.data.vote.voting_guard
-      );
-      if (this.data.vote.voting_guard) {
-        add_guard(this.data.vote.voting_guard);
-      } else {
-        (0, import_exception.W_ERROR)(
-          import_exception.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(import_permission.BuiltinPermissionIndex.ARBITRATION_VOTING_GUARD);
-    }
-    if (this.permission_address && this.data?.pause !== void 0) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_PAUSE);
-    }
-    if (this.permission_address && this.data?.owner_receive != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_OWNER_RECEIVE);
-    }
-    if (this.permission_address && this.data?.arbitration != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_ARBITRATION);
-    }
-    if (this.permission_address && this.data?.feedback != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_FEEDBACK);
-    }
-    if (this.permission_address && this.data?.confirm != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_CONFIRM);
-    }
-    if (this.permission_address && this.data?.voting_deadline_change != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_VOTING_DEADLINE_CHANGE);
-    }
-    if (this.permission_address && this.data?.reset != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_RESET);
-    }
-    if (this.permission_address && this.data?.arb_withdraw != null) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_ARB_WITHDRAW);
-    }
-    if (this.permission_address && this.data?.fees_transfer != null) {
-      if ("allocator" in this.data.fees_transfer.to) {
-        add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_FEES_ALLOC);
-      } else if ("treasury" in this.data.fees_transfer.to) {
-        add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_FEES_TRANSFER);
-      } else {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.fees_withdraw.to is invalid"
-        );
-      }
-    }
-    if (this.permission_address && this.data.um !== void 0) {
-      add_perm(import_permission.BuiltinPermissionIndex.ARBITRATION_UM);
-    }
-    if (this.permission_address || guards.length > 0) {
-      return await this.check_permission_and_call(
-        env,
-        this.permission_address,
-        perms,
-        guards
-      );
-    }
-    return await this.exec(env);
-  }
-  async operate(env, tx, passport, submission) {
-    let permission = this.permission_address;
-    let object = this.object_address;
-    if (!this.object_address) {
-      if (!permission) {
-        permission = (0, import_permission.newPermission)(
-          tx,
-          this.new_permission_description ?? ""
-        );
-      }
-      if (permission && this.parameter_type) {
-        object = newArbitration(
-          tx,
-          this.parameter_type,
-          permission,
-          this.data?.description ?? "",
-          passport
-        );
-      }
-    }
-    if (!object || !permission) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        "CallArbitration_Data.data.object:" + this.object_address
-      );
-    }
-    if (this.data.dispute != null) {
-      const order = await import_local.LocalMark.Instance().get_address(
-        this.data.dispute.order
-      );
-      if (!order) {
-        (0, import_exception.W_ERROR)(
-          import_exception.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,
-        import_object.ObjectType.Arb,
-        (0, import_arb2.create)(tx, arb, this.parameter_type),
-        (0, import_common.GetObject)(this.data?.dispute.namedArb)
-      );
-    }
-    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.fee != null) {
-      fee_set(
-        tx,
-        object,
-        this.parameter_type,
-        permission,
-        this.data.fee,
-        passport
-      );
-    }
-    if (this.data.pause != null) {
-      pause(
-        tx,
-        object,
-        this.parameter_type,
-        permission,
-        this.data.pause,
-        passport
-      );
-    }
-    if (this.data.confirm != null) {
-      const arb = await import_local.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, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.confirm.arb:" + this.data.confirm.arb
-        );
-      }
-    }
-    if (this.data.voting_deadline_change != null) {
-      const arb = await import_local.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, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.voting_deadline_change.arb:" + this.data.voting_deadline_change.arb
-        );
-      }
-    }
-    if (this.data.vote != null) {
-      const arb = await import_local.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, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.vote.arb:" + this.data.vote.arb
-        );
-      }
-    }
-    if (this.data.feedback != null) {
-      const arb = await import_local.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, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.feedback.arb:" + this.data.feedback.arb
-        );
-      }
-    }
-    if (this.data.arbitration != null) {
-      const arb = await import_local.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, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.arbitration.arb:" + this.data.arbitration.arb
-        );
-      }
-    }
-    if (this.data.reset != null) {
-      const arb = await import_local.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, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.reset.arb:" + this.data.reset.arb
-        );
-      }
-    }
-    if (this.data.arb_withdraw != null) {
-      const arb = await import_local.LocalMark.Instance().get_address(
-        this.data.arb_withdraw.arb
-      );
-      if (arb) {
-        arb_withdraw(
-          tx,
-          object,
-          this.parameter_type,
-          permission,
-          arb,
-          passport
-        );
-      } else {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallArbitration_Data.data.arb_withdraw.arb:" + this.data.arb_withdraw.arb
-        );
-      }
-    }
-    if (this.data.fees_transfer != null) {
-      let payment_address = void 0;
-      if ("allocation" in this.data.fees_transfer.to) {
-        const a = await import_local.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, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            "CallArbitration_Data.data.fees_transfer.to.allocation:" + this.data.fees_transfer.to.allocation
-          );
+// 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");
+// ================================================
+// 数据操作类
+class CallArbitration extends base_js_1.CallBase {
+    data;
+    object_address = undefined;
+    permission_address = undefined;
+    new_permission_description = undefined;
+    parameter_type = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async prepare(env) {
+        await super.prepare(env);
+        if (!this.object_address) {
+            this.object_address = await (0, common_js_1.GetObjectExisted)(this.data?.object);
         }
-      } else if ("treasury" in this.data.fees_transfer.to) {
-        const t = await import_local.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, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            "CallArbitration_Data.data.fees_transfer.to.treasury:" + this.data.fees_transfer.to.treasury
-          );
+        if (this.object_address) {
+            await this.update_content(env, object_js_1.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);
+            this.permission_address = this.content.permission;
+            this.parameter_type = (0, util_js_1.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");
+            }
+            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");
+            }
         }
-      } else {
-        (0, import_exception.W_ERROR)(
-          import_exception.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,
-          import_object.ObjectType.Payment,
-          payment_address,
-          this.data.fees_transfer.newPayment
-        );
-      }
-    }
-    if (this.data.usage_guard !== void 0) {
-      if (this.data.usage_guard) {
-        const guard = await import_local.LocalMark.Instance().get_address(
-          this.data.usage_guard
-        );
-        if (guard) {
-          usage_guard_set(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            guard,
-            passport
-          );
+        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);
+            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");
+            }
         }
-      } else {
-        usage_guard_none(
-          tx,
-          object,
-          this.parameter_type,
-          permission,
-          passport
-        );
-      }
-    }
-    if (this.data.voting_guard != null) {
-      switch (this.data.voting_guard.op) {
-        case "add":
-        case "set": {
-          if (this.data.voting_guard.guards.length > MAX_VOTING_GUARD_COUNT) {
-            (0, import_exception.W_ERROR)(
-              import_exception.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 import_local.LocalMark.Instance().get_address(
-                vg.guard
-              );
-              return {
-                originalGuard: vg.guard,
-                guard,
-                vote_weight: vg.vote_weight
-              };
-            })
-          );
-          const invalidGuards = guards.filter((vg) => vg.guard === void 0).map((vg) => vg.originalGuard);
-          if (invalidGuards.length > 0) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Invalid voting guards: ${invalidGuards.join(", ")} could not be resolved to valid addresses`
-            );
-          }
-          const voting_guards = guards.map((vg) => ({
-            guard: vg.guard,
-            vote_weight: vg.vote_weight
-          }));
-          voting_guard_add(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            voting_guards,
-            passport
-          );
-          break;
+    }
+    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);
+            }
+        };
+        const obj = this.content;
+        if (this.permission_address && !this.object_address) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_NEW);
         }
-        case "remove": {
-          const guards = await import_local.LocalMark.Instance().get_many_address_availables(
-            this.data.voting_guard.guards
-          );
-          if (guards.length > MAX_VOTING_GUARD_COUNT) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Voting guard count exceeds maximum count ${MAX_VOTING_GUARD_COUNT}`
-            );
-          }
-          voting_guard_remove(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            guards,
-            passport
-          );
-          break;
+        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");
+            }
+            if (obj.usage_guard) {
+                add_guard(obj.usage_guard);
+            }
         }
-        case "clear": {
-          voting_guard_clear(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            passport
-          );
-          break;
+        if (this.permission_address &&
+            this.data?.description != null &&
+            this.object_address) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_DESCRIPTION);
         }
-      }
-    }
-    if (this.data.owner_receive != null && this.object_address) {
-      if (this.data.owner_receive === "recently") {
-        this.data.owner_receive = await (0, import_received.query_received)({
-          object: this.object_address,
-          all_type: true,
-          no_cache: env.no_cache,
-          network: env.network
-        });
-      }
-      await (0, import_util.owner_receive)(
-        tx,
-        object,
-        permission,
-        this.data.owner_receive,
-        this.parameter_type,
-        (name) => `${import_common.PackageAddress}::arbitration::${name}`,
-        passport
-      );
-    }
-    if (this.data.um !== void 0) {
-      let um_address = null;
-      if (this.data.um) {
-        um_address = await import_local.LocalMark.Instance().get_address(this.data.um) || null;
-        if (!um_address) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            "CallArbitration_Data.data.um:" + this.data.um
-          );
+        if (this.permission_address && this.data?.location != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_LOCATION);
         }
-      }
-      um_set(
-        tx,
-        object,
-        this.parameter_type,
-        permission,
-        um_address,
-        passport
-      );
-    }
-    if (!this.permission_address) {
-      const p = (0, import_common.GetObject)(
-        this.data?.object
-      );
-      await this.new_with_mark(
-        env,
-        tx,
-        import_object.ObjectType.Permission,
-        (0, import_permission2.create)(tx, permission),
-        (0, import_common.GetObject)(p.permission)
-      );
-    }
-    if (!this.object_address) {
-      await this.new_with_mark(
-        env,
-        tx,
-        import_object.ObjectType.Arbitration,
-        create(tx, object, this.parameter_type),
-        (0, import_common.GetObject)(this.data?.object)
-      );
-    }
-  }
-}
-const MAX_VOTING_GUARD_COUNT = 50;
-function create(tx, arbitration2, parameter_type) {
-  (0, import_util.validObjects)([arbitration2]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  return tx.moveCall({
-    target: (0, import_common.arbitrationFn)(`create`),
-    arguments: [(0, import_common.toTxObject)(tx, arbitration2)],
-    typeArguments: [parameter_type]
-  });
+        if (this.permission_address && this.data?.fee != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEE);
+        }
+        if (this.permission_address && this.data?.usage_guard !== undefined) {
+            add_perm(permission_js_1.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);
+            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`);
+            }
+        }
+        if (this.permission_address && this.data?.voting_guard != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_VOTING_GUARD);
+        }
+        if (this.permission_address && this.data?.pause !== undefined) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_PAUSE);
+        }
+        if (this.permission_address && this.data?.owner_receive != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_OWNER_RECEIVE);
+        }
+        // 处理 arbitration 操作权限
+        if (this.permission_address && this.data?.arbitration != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_ARBITRATION);
+        }
+        // 处理 feedback 操作权限
+        if (this.permission_address && this.data?.feedback != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEEDBACK);
+        }
+        // 处理 confirm 操作权限
+        if (this.permission_address && this.data?.confirm != null) {
+            add_perm(permission_js_1.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);
+        }
+        // 处理 reset 操作权限
+        if (this.permission_address && this.data?.reset != null) {
+            add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_RESET);
+        }
+        // 处理 arb_withdraw 操作权限
+        if (this.permission_address && this.data?.arb_withdraw != null) {
+            add_perm(permission_js_1.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);
+            }
+            else if ("treasury" in this.data.fees_transfer.to) {
+                add_perm(permission_js_1.BuiltinPermissionIndex.ARBITRATION_FEES_TRANSFER);
+            }
+            else {
+                (0, exception_js_1.W_ERROR)(exception_js_1.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);
+        }
+        if (this.permission_address || guards.length > 0) {
+            return await this.check_permission_and_call(env, this.permission_address, perms, guards);
+        }
+        return await this.exec(env);
+    }
+    async operate(env, tx, passport, submission) {
+        let permission = this.permission_address;
+        let object = this.object_address;
+        if (!this.object_address) {
+            if (!permission) {
+                permission = (0, permission_js_1.newPermission)(tx, this.new_permission_description ?? "");
+            }
+            if (permission && this.parameter_type) {
+                object = 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);
+        }
+        if (this.data.dispute != null) {
+            const order = await local_js_1.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:" +
+                    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));
+        }
+        // 处理 description 更新
+        if (this.data.description != null && this.object_address) {
+            description_set(tx, object, this.parameter_type, permission, this.data.description, passport);
+        }
+        // 处理 location 更新
+        if (this.data.location != null) {
+            location_set(tx, object, this.parameter_type, permission, this.data.location, passport);
+        }
+        // 处理 fee 更新
+        if (this.data.fee != null) {
+            fee_set(tx, object, this.parameter_type, permission, this.data.fee, passport);
+        }
+        // 处理 pause 更新
+        if (this.data.pause != null) {
+            pause(tx, object, this.parameter_type, permission, this.data.pause, passport);
+        }
+        // 处理 confirm 操作
+        if (this.data.confirm != null) {
+            const arb = await local_js_1.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:" +
+                    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);
+            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:" +
+                    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);
+            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);
+            }
+        }
+        // 处理 feedback 操作
+        if (this.data.feedback != null) {
+            const arb = await local_js_1.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:" +
+                    this.data.feedback.arb);
+            }
+        }
+        // 处理 arbitration 操作
+        if (this.data.arbitration != null) {
+            const arb = await local_js_1.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:" +
+                    this.data.arbitration.arb);
+            }
+        }
+        // 处理 reset 操作
+        if (this.data.reset != null) {
+            const arb = await local_js_1.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:" +
+                    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);
+            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:" +
+                    this.data.arb_withdraw.arb);
+            }
+        }
+        // 处理 fees_transfer 操作
+        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);
+                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:" +
+                        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);
+                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:" +
+                        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");
+            }
+            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);
+            }
+        }
+        // 处理 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);
+                if (guard) {
+                    usage_guard_set(tx, object, this.parameter_type, permission, guard, passport);
+                }
+            }
+            else {
+                usage_guard_none(tx, object, this.parameter_type, permission, passport);
+            }
+        }
+        // 处理 voting_guard 更新
+        if (this.data.voting_guard != null) {
+            switch (this.data.voting_guard.op) {
+                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}`);
+                    }
+                    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);
+                        return {
+                            originalGuard: vg.guard,
+                            guard,
+                            vote_weight: vg.vote_weight,
+                        };
+                    }));
+                    const invalidGuards = guards
+                        .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`);
+                    }
+                    const voting_guards = guards.map((vg) => ({
+                        guard: vg.guard,
+                        vote_weight: vg.vote_weight,
+                    }));
+                    voting_guard_add(tx, object, this.parameter_type, permission, voting_guards, passport);
+                    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}`);
+                    }
+                    voting_guard_remove(tx, object, this.parameter_type, permission, guards, passport);
+                    break;
+                }
+                case "clear": {
+                    voting_guard_clear(tx, object, this.parameter_type, permission, passport);
+                    break;
+                }
+            }
+        }
+        // 处理 owner_receive
+        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)({
+                    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);
+        }
+        // 处理 um
+        if (this.data.um !== undefined) {
+            let um_address = null;
+            if (this.data.um) {
+                um_address =
+                    (await local_js_1.LocalMark.Instance().get_address(this.data.um)) ||
+                        null;
+                if (!um_address) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "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));
+        }
+        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));
+        }
+    }
 }
-function newArbitration(tx, parameter_type, permission, description, passport) {
-  (0, import_util.validObjects)([permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(description)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration description ${description} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (passport) {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`new_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.pure.string(description),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
+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`);
+    }
     return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`new`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.string(description),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
-}
-function description_set(tx, arbitration2, parameter_type, permission, description, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(description)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration description ${description} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`description_set_with_passsport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.pure.string(description)
-      ],
-      typeArguments: [parameter_type]
+        target: (0, common_js_1.arbitrationFn)(`create`),
+        arguments: [(0, common_js_1.toTxObject)(tx, arbitration)],
+        typeArguments: [parameter_type],
     });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`description_set`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.string(description)
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
 }
-function location_set(tx, arbitration2, parameter_type, permission, location, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidLongName)(location)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration location ${location} is exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`location_set_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.pure.string(location)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`location_set`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.string(location)
-      ],
-      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`);
+    }
+    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 (passport) {
+        return tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`new_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.pure.string(description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`new`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.string(description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function voting_guard_add(tx, arbitration2, parameter_type, permission, voting_guards, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  voting_guards.forEach((vg) => {
-    if (!(0, import_sui_types.isValidWowAddress)(vg.guard)) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `Voting guard ${vg.guard} is not valid`
-      );
-    }
-    if ("GuardIdentifier" in vg.vote_weight) {
-      if (!(0, import_common.isValidU8)(vg.vote_weight.GuardIdentifier)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          `Voting guard ${vg.vote_weight.GuardIdentifier} must be u8 number`
-        );
-      }
-      if (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`);
+    }
+    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 (passport) {
         tx.moveCall({
-          target: (0, import_common.arbitrationFn)(
-            `voting_guard_add_by_id_add_with_passport`
-          ),
-          arguments: [
-            (0, import_common.toTxObject)(tx, arbitration2),
-            (0, import_common.toTxObject)(tx, permission),
-            passport,
-            tx.object(vg.guard),
-            tx.pure.u8(vg.vote_weight.GuardIdentifier)
-          ],
-          typeArguments: [parameter_type]
+            target: (0, common_js_1.arbitrationFn)(`description_set_with_passsport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.pure.string(description),
+            ],
+            typeArguments: [parameter_type],
         });
-      } else {
+    }
+    else {
         tx.moveCall({
-          target: (0, import_common.arbitrationFn)(`voting_guard_add_by_id_add`),
-          arguments: [
-            (0, import_common.toTxObject)(tx, arbitration2),
-            (0, import_common.toTxObject)(tx, permission),
-            tx.object(vg.guard),
-            tx.pure.u8(vg.vote_weight.GuardIdentifier)
-          ],
-          typeArguments: [parameter_type]
+            target: (0, common_js_1.arbitrationFn)(`description_set`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.string(description),
+            ],
+            typeArguments: [parameter_type],
         });
-      }
-    } else if ("FixedValue" in vg.vote_weight) {
-      if (!(0, import_common.isValidU32)(vg.vote_weight.FixedValue)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          `Voting guard ${vg.vote_weight.FixedValue} must be u32 number`
-        );
-      }
-      if (passport) {
+    }
+}
+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`);
+    }
+    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 (passport) {
         tx.moveCall({
-          target: (0, import_common.arbitrationFn)(
-            `voting_guard_fixed_add_with_passport`
-          ),
-          arguments: [
-            (0, import_common.toTxObject)(tx, arbitration2),
-            (0, import_common.toTxObject)(tx, permission),
-            passport,
-            tx.object(vg.guard),
-            tx.pure.u32(vg.vote_weight.FixedValue),
-            tx.object.mutRegistrar(),
-            tx.object.clock()
-          ],
-          typeArguments: [parameter_type]
+            target: (0, common_js_1.arbitrationFn)(`location_set_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.pure.string(location),
+            ],
+            typeArguments: [parameter_type],
         });
-      } else {
+    }
+    else {
         tx.moveCall({
-          target: (0, import_common.arbitrationFn)(`voting_guard_fixed_add`),
-          arguments: [
-            (0, import_common.toTxObject)(tx, arbitration2),
-            (0, import_common.toTxObject)(tx, permission),
-            tx.object(vg.guard),
-            tx.pure.u32(vg.vote_weight.FixedValue),
-            tx.object.mutRegistrar(),
-            tx.object.clock()
-          ],
-          typeArguments: [parameter_type]
+            target: (0, common_js_1.arbitrationFn)(`location_set`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.string(location),
+            ],
+            typeArguments: [parameter_type],
         });
-      }
     }
-  });
-}
-function voting_guard_remove(tx, arbitration2, parameter_type, permission, guards, passport) {
-  if (guards.length === 0) {
-    return;
-  }
-  (0, import_util.validObjects)([arbitration2, permission, ...guards]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`voting_guard_remove_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.pure.vector("address", guards),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`voting_guard_remove`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.vector("address", guards),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
 }
-function voting_guard_clear(tx, arbitration2, parameter_type, permission, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`voting_guard_clear_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`voting_guard_clear`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.object.mutRegistrar()
-      ],
-      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`);
+    }
+    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 ("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 (passport) {
+                tx.moveCall({
+                    target: (0, common_js_1.arbitrationFn)(`voting_guard_add_by_id_add_with_passport`),
+                    arguments: [
+                        (0, common_js_1.toTxObject)(tx, arbitration),
+                        (0, common_js_1.toTxObject)(tx, permission),
+                        passport,
+                        tx.object(vg.guard),
+                        tx.pure.u8(vg.vote_weight.GuardIdentifier),
+                    ],
+                    typeArguments: [parameter_type],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: (0, common_js_1.arbitrationFn)(`voting_guard_add_by_id_add`),
+                    arguments: [
+                        (0, common_js_1.toTxObject)(tx, arbitration),
+                        (0, common_js_1.toTxObject)(tx, permission),
+                        tx.object(vg.guard),
+                        tx.pure.u8(vg.vote_weight.GuardIdentifier),
+                    ],
+                    typeArguments: [parameter_type],
+                });
+            }
+        }
+        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 (passport) {
+                tx.moveCall({
+                    target: (0, common_js_1.arbitrationFn)(`voting_guard_fixed_add_with_passport`),
+                    arguments: [
+                        (0, common_js_1.toTxObject)(tx, arbitration),
+                        (0, common_js_1.toTxObject)(tx, permission),
+                        passport,
+                        tx.object(vg.guard),
+                        tx.pure.u32(vg.vote_weight.FixedValue),
+                        tx.object.mutRegistrar(),
+                        tx.object.clock(),
+                    ],
+                    typeArguments: [parameter_type],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: (0, common_js_1.arbitrationFn)(`voting_guard_fixed_add`),
+                    arguments: [
+                        (0, common_js_1.toTxObject)(tx, arbitration),
+                        (0, common_js_1.toTxObject)(tx, permission),
+                        tx.object(vg.guard),
+                        tx.pure.u32(vg.vote_weight.FixedValue),
+                        tx.object.mutRegistrar(),
+                        tx.object.clock(),
+                    ],
+                    typeArguments: [parameter_type],
+                });
+            }
+        }
     });
-  }
 }
-function usage_guard_set(tx, arbitration2, parameter_type, permission, guard, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, guard]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`usage_guard_set_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.object(guard),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`usage_guard_set`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.object(guard),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
+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`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`voting_guard_remove_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.pure.vector("address", guards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`voting_guard_remove`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.vector("address", guards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function usage_guard_none(tx, arbitration2, parameter_type, permission, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`usage_guard_none_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`usage_guard_none`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
+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`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`voting_guard_clear_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`voting_guard_clear`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function pause(tx, arbitration2, parameter_type, permission, pause2, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`pause_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.pure.bool(pause2)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`pause`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.bool(pause2)
-      ],
-      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`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`usage_guard_set_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.object(guard),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`usage_guard_set`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.object(guard),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function fee_set(tx, arbitration2, parameter_type, permission, fee, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidU64)(fee)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Fee ${fee} is not valid u64`);
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`fee_set_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        tx.pure.u64(fee)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`fee_set`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.u64(fee)
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
+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`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`usage_guard_none_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`usage_guard_none`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-async function dispute(env, tx, arbitration2, parameter_type, order, description, proposition, fee, passport) {
-  (0, import_util.validObjects)([arbitration2, order]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(description)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidDescription,
-      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (proposition.length > import_arb.MAX_PROPOSITION_COUNT) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Proposition count exceeds maximum count ${import_arb.MAX_PROPOSITION_COUNT}`
-    );
-  }
-  if (!(0, import_common.isValidArray)(proposition, import_common.isValidLongName)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Proposition ${proposition} is not valid array of string, each string must less than ${import_common.MAX_LONG_NAME_LENGTH}`
-    );
-  }
-  const c = await (0, import_base.getCoinParam)(env, tx, fee, parameter_type);
-  if (passport) {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`dispute_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        passport,
-        (0, import_common.toTxObject)(tx, order),
-        tx.pure.string(description),
-        tx.pure.vector("string", proposition),
-        c,
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`dispute`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, order),
-        tx.pure.string(description),
-        tx.pure.vector("string", proposition),
-        c,
-        tx.object.clock()
-      ],
-      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`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`pause_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.pure.bool(pause),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`pause`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.bool(pause),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function vote(tx, arbitration2, parameter_type, permission, arb, votes, voting_guard, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb, voting_guard]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidArray)(votes, import_common.isValidU8)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Votes ${votes} is not valid array of u8`
-    );
-  }
-  if (passport) {
-    if (voting_guard) {
-      tx.moveCall({
-        target: (0, import_common.arbitrationFn)(`vote_with_voting_guard`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, arbitration2),
-          passport,
-          (0, import_common.toTxObject)(tx, arb),
-          (0, import_common.toTxObject)(tx, voting_guard),
-          tx.pure.vector("u8", votes),
-          tx.object.clock()
-        ],
-        typeArguments: [parameter_type]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.arbitrationFn)(`vote_with_passport`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, arbitration2),
-          (0, import_common.toTxObject)(tx, permission),
-          passport,
-          (0, import_common.toTxObject)(tx, arb),
-          tx.pure.vector("u8", votes),
-          tx.object.clock()
-        ],
-        typeArguments: [parameter_type]
-      });
-    }
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`vote`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.vector("u8", votes),
-        tx.object.clock()
-      ],
-      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`);
+    }
+    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 (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`fee_set_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                tx.pure.u64(fee),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`fee_set`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.u64(fee),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function arbitration(tx, arbitration2, parameter_type, permission, arb, feedback2, indemnity, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(feedback2)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Feedback ${feedback2} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (!(0, import_common.isValidU64)(indemnity)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Indemnity ${indemnity} must be u64 number`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`arbitration_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.string(feedback2),
-        tx.pure.u64(indemnity),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`arbitration`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.string(feedback2),
-        tx.pure.u64(indemnity),
-        tx.object.clock()
-      ],
-      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`);
+    }
+    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 (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 (!(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}`);
+    }
+    const c = await (0, base_js_1.getCoinParam)(env, tx, fee, parameter_type);
+    if (passport) {
+        return tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`dispute_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                passport,
+                (0, common_js_1.toTxObject)(tx, order),
+                tx.pure.string(description),
+                tx.pure.vector("string", proposition),
+                c,
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`dispute`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, order),
+                tx.pure.string(description),
+                tx.pure.vector("string", proposition),
+                c,
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function feedback(tx, arbitration2, parameter_type, permission, arb, feedback2, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(feedback2)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Feedback ${feedback2} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`feedback_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.string(feedback2)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`feedback`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.string(feedback2)
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
+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`);
+    }
+    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 (passport) {
+        // voting by voting-guard
+        if (voting_guard) {
+            tx.moveCall({
+                target: (0, common_js_1.arbitrationFn)(`vote_with_voting_guard`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, arbitration),
+                    passport,
+                    (0, common_js_1.toTxObject)(tx, arb),
+                    (0, common_js_1.toTxObject)(tx, voting_guard),
+                    tx.pure.vector("u8", votes),
+                    tx.object.clock(),
+                ],
+                typeArguments: [parameter_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.arbitrationFn)(`vote_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, arbitration),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    (0, common_js_1.toTxObject)(tx, arb),
+                    tx.pure.vector("u8", votes),
+                    tx.object.clock(),
+                ],
+                typeArguments: [parameter_type],
+            });
+        }
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`vote`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.vector("u8", votes),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function confirm(tx, arbitration2, parameter_type, permission, arb, voting_deadline, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (voting_deadline !== null && !(0, import_common.isValidU64)(voting_deadline)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Voting deadline ${voting_deadline} must be u64 number or null`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`confirm_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.option("u64", voting_deadline)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`confirm`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.option("u64", voting_deadline)
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
+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`);
+    }
+    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 (!(0, common_js_1.isValidU64)(indemnity)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Indemnity ${indemnity} must be u64 number`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`arbitration_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.string(feedback),
+                tx.pure.u64(indemnity),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`arbitration`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.string(feedback),
+                tx.pure.u64(indemnity),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function voting_deadline_change(tx, arbitration2, parameter_type, permission, arb, voting_deadline, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (voting_deadline !== null && !(0, import_common.isValidU64)(voting_deadline)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Voting deadline ${voting_deadline} must be u64 number or null`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`voting_deadline_change_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.option("u64", voting_deadline)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`voting_deadline_change`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.option("u64", voting_deadline)
-      ],
-      typeArguments: [parameter_type]
-    });
-  }
+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`);
+    }
+    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 (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`feedback_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.string(feedback),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`feedback`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.string(feedback),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function reset(tx, arbitration2, parameter_type, permission, arb, feedback2, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(feedback2)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Feedback ${feedback2} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`reset_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.string(feedback2)
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`reset`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.pure.string(feedback2)
-      ],
-      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`);
+    }
+    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 (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`confirm_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.option("u64", voting_deadline),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`confirm`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.option("u64", voting_deadline),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function arb_withdraw(tx, arbitration2, parameter_type, permission, arb, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, arb]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`arb_withdraw_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, arb),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`arb_withdraw`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, arb),
-        tx.object.clock()
-      ],
-      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`);
+    }
+    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 (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`voting_deadline_change_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.option("u64", voting_deadline),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.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),
+                tx.pure.option("u64", voting_deadline),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function fees_alloc(tx, arbitration2, parameter_type, permission, allocation, payment_remark, payment_index, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, allocation]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(payment_remark)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Payment remark ${payment_remark} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (!(0, import_common.isValidU64)(payment_index)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Payment index ${payment_index} must be u64 number`
-    );
-  }
-  if (passport) {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`fees_alloc_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, allocation),
-        tx.pure.string(payment_remark),
-        tx.pure.u64(payment_index),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`fees_alloc`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, allocation),
-        tx.pure.string(payment_remark),
-        tx.pure.u64(payment_index),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      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`);
+    }
+    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 (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`reset_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.string(feedback),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`reset`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.pure.string(feedback),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function fees_transfer(tx, arbitration2, parameter_type, permission, treasury, payment_remark, payment_index, passport) {
-  (0, import_util.validObjects)([arbitration2, permission, treasury]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (!(0, import_common.isValidDescription)(payment_remark)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Payment remark ${payment_remark} exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (!(0, import_common.isValidU64)(payment_index)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Payment index ${payment_index} must be u64 number`
-    );
-  }
-  if (passport) {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`fees_transfer_with_passport`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        passport,
-        (0, import_common.toTxObject)(tx, treasury),
-        tx.pure.string(payment_remark),
-        tx.pure.u64(payment_index),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [parameter_type]
-    });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.arbitrationFn)(`fees_transfer`),
-      arguments: [
-        (0, import_common.toTxObject)(tx, arbitration2),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, treasury),
-        tx.pure.string(payment_remark),
-        tx.pure.u64(payment_index),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      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`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`arb_withdraw_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, arb),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.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),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
 }
-function um_set(tx, arbitration2, parameter_type, permission, um, passport) {
-  (0, import_util.validObjects)([arbitration2, permission]);
-  if (!(0, import_common.IsValidArgType)(parameter_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Arbitration type ${parameter_type} is not valid`
-    );
-  }
-  if (um) {
+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`);
+    }
+    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 (!(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 (passport) {
-      tx.moveCall({
-        target: (0, import_common.arbitrationFn)(`um_set_with_passport`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, arbitration2),
-          (0, import_common.toTxObject)(tx, permission),
-          passport,
-          (0, import_common.toTxObject)(tx, um),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [parameter_type]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.arbitrationFn)(`um_set`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, arbitration2),
-          (0, import_common.toTxObject)(tx, permission),
-          (0, import_common.toTxObject)(tx, um),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [parameter_type]
-      });
-    }
-  } else {
+        return tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`fees_alloc_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, allocation),
+                tx.pure.string(payment_remark),
+                tx.pure.u64(payment_index),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.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),
+                tx.pure.string(payment_remark),
+                tx.pure.u64(payment_index),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+}
+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`);
+    }
+    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 (!(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 (passport) {
-      tx.moveCall({
-        target: (0, import_common.arbitrationFn)(`um_none_with_passport`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, arbitration2),
-          (0, import_common.toTxObject)(tx, permission),
-          passport,
-          tx.object.mutRegistrar()
-        ],
-        typeArguments: [parameter_type]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.arbitrationFn)(`um_none`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, arbitration2),
-          (0, import_common.toTxObject)(tx, permission),
-          tx.object.mutRegistrar()
-        ],
-        typeArguments: [parameter_type]
-      });
-    }
-  }
+        return tx.moveCall({
+            target: (0, common_js_1.arbitrationFn)(`fees_transfer_with_passport`),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, arbitration),
+                (0, common_js_1.toTxObject)(tx, permission),
+                passport,
+                (0, common_js_1.toTxObject)(tx, treasury),
+                tx.pure.string(payment_remark),
+                tx.pure.u64(payment_index),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.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),
+                tx.pure.string(payment_remark),
+                tx.pure.u64(payment_index),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [parameter_type],
+        });
+    }
+}
+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`);
+    }
+    if (um) {
+        if (passport) {
+            tx.moveCall({
+                target: (0, common_js_1.arbitrationFn)(`um_set_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, arbitration),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    (0, common_js_1.toTxObject)(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [parameter_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.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),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [parameter_type],
+            });
+        }
+    }
+    else {
+        if (passport) {
+            tx.moveCall({
+                target: (0, common_js_1.arbitrationFn)(`um_none_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, arbitration),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [parameter_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.arbitrationFn)(`um_none`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, arbitration),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [parameter_type],
+            });
+        }
+    }
 }
+//# sourceMappingURL=arbitration.js.map