wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1623 @@
+"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
+          );
+        }
+      } 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
+          );
+        }
+      } 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 {
+        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;
+        }
+        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;
+        }
+        case "clear": {
+          voting_guard_clear(
+            tx,
+            object,
+            this.parameter_type,
+            permission,
+            passport
+          );
+          break;
+        }
+      }
+    }
+    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
+          );
+        }
+      }
+      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]
+  });
+}
+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 {
+    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]
+    });
+  } 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 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) {
+        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]
+        });
+      } 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]
+        });
+      }
+    } 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) {
+        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]
+        });
+      } 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]
+        });
+      }
+    }
+  });
+}
+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 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 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 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 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]
+    });
+  }
+}
+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 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 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]
+    });
+  }
+}
+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 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 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 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 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 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 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 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) {
+    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 {
+    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]
+      });
+    }
+  }
+}