wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,433 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isValidWowAddress } from "../../utils/sui-types.js";
+import {
+  toTxObject,
+  isValidDescription,
+  MAX_DESCRIPTION_LENGTH,
+  PackageAddress,
+  isValidU8,
+  isValidU64,
+  GetObjectExisted,
+  GetObject,
+  IsValidArgType
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import {
+  GetAccountOrMark_Address,
+  GetManyAccountOrMark_Address
+} from "../local/index.js";
+import { LocalMark } from "../local/local.js";
+import { ObjectType } from "../query/object.js";
+import { query_received } from "../query/received.js";
+import { parseObjectType, validObjects } from "../util.js";
+import { CallBase, getCoinParam } from "./base.js";
+import { get_guardSubmissions } from "./passport.js";
+import { paymentInfo } from "./payment.js";
+class CallAllocation extends CallBase {
+  //object_data: ObjectPermission | undefined = undefined;
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "type_parameter");
+    this.data = data;
+  }
+  async prepare(env) {
+    await super.prepare(env);
+    if (!this.object_address) {
+      this.object_address = await GetObjectExisted(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        ObjectType.Allocation,
+        this.object_address
+      );
+      if (!this.content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallAllocation_Data.data.object:" + this.object_address
+        );
+      }
+      this.type_parameter = parseObjectType(
+        this.content.type_raw,
+        "allocation::Allocation"
+      );
+      if (!this.type_parameter) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallAllocation_Data.data.object.type_parameter is empty"
+        );
+      }
+    } else {
+      const n = GetObject(this.data.object);
+      if (!n || !IsValidArgType(n?.type_parameter)) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallAllocation_Data.data.object.type_parameter is empty"
+        );
+      }
+      this.type_parameter = n?.type_parameter;
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
+      const g = await LocalMark.Instance().get_address(
+        this.data.alloc_by_guard
+      );
+      if (!g || !isValidWowAddress(g)) {
+        W_ERROR(
+          WErrors.IsValidAddress,
+          `alloc_by_guard: ${this.data.alloc_by_guard}`
+        );
+      }
+      if (this.content && !this.content.allocators.find(
+        (item) => item.guard === g
+      )) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `alloc_by_guard: ${this.data.alloc_by_guard} not found in allocators ${this.content.allocators.map((item) => item.guard)}`
+        );
+      }
+      this.data.alloc_by_guard = g;
+      const param = await get_guardSubmissions(env, [
+        this.data.alloc_by_guard
+      ]);
+      if (param.submission.length > 0) {
+        return {
+          type: "submission",
+          guard: param.guard,
+          submission: param.submission
+        };
+      }
+      return await this.check_passport(env, param);
+    }
+    return await this.exec(env);
+  }
+  async operate(env, tx, passport) {
+    if (this.object_address) {
+      if ("received_coins" in this.data && this.data.received_coins != null) {
+        if (this.data.received_coins === "recently") {
+          const received = await query_received({
+            object: this.object_address,
+            network: env.network,
+            no_cache: env.no_cache
+          });
+          if (Array.isArray(received)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]"
+            );
+          } else {
+            this.data.received_coins = received;
+          }
+        }
+        if (typeof this.data.received_coins === "object" && "received" in this.data.received_coins && this.data.received_coins.received?.length > 0) {
+          if (this.data.received_coins?.token_type !== this.type_parameter) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              "CallAllocation_Data.data.received_coins.token_type:" + this.data.received_coins?.token_type
+            );
+          }
+          for (const v of this.data.received_coins.received) {
+            if (!isValidWowAddress(v.id) || !isValidWowAddress(v.payment)) {
+              W_ERROR(
+                WErrors.InvalidParam,
+                "CallAllocation_Data.data.received_coins:" + v.id
+              );
+            }
+            receive(
+              tx,
+              toTxObject(tx, this.object_address),
+              this.type_parameter,
+              toTxObject(tx, v.id),
+              toTxObject(tx, v.payment)
+            );
+          }
+        }
+      }
+      if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
+        if (!passport) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallAllocation_Data.data.alloc_by_guard:" + this.data.alloc_by_guard
+          );
+        }
+        alloc(
+          tx,
+          toTxObject(tx, this.object_address),
+          this.type_parameter,
+          this.data.alloc_by_guard,
+          passport
+        );
+      }
+    } else {
+      const n = GetObject(this.data.object);
+      if (!IsValidArgType(n?.type_parameter)) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          `CallAllocation_Data.data.object.type_parameter ${n?.type_parameter}`
+        );
+      }
+      this.type_parameter = n?.type_parameter;
+      let coin;
+      if ("coin" in this.data && this.data.coin) {
+        coin = await getCoinParam(
+          env,
+          tx,
+          this.data.coin,
+          this.type_parameter
+        );
+      }
+      if (coin && "allocators" in this.data && this.data.allocators && this.type_parameter) {
+        const allocation = newAllocation(
+          tx,
+          this.type_parameter,
+          coin,
+          await allocators(tx, this.data.allocators)
+        );
+        await this.new_with_mark(
+          env,
+          tx,
+          ObjectType.Allocation,
+          create(
+            tx,
+            allocation,
+            this.type_parameter,
+            await paymentInfo(env, tx, this.data.payment_info)
+          ),
+          n
+        );
+      } else {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallAllocation_Data.data ${JSON.stringify(this.data)}`
+        );
+      }
+    }
+  }
+}
+function allocationFn(name) {
+  return `${PackageAddress}::allocation::${name}`;
+}
+const MAX_ALLOCATOR_COUNT = 100;
+const MAX_SHARING_COUNT = 100;
+const sharing = async (tx, sharing2, preResolvedAddress) => {
+  if ("GuardIdentifier" in sharing2.who) {
+    if (!isValidU8(sharing2.who.GuardIdentifier)) {
+      W_ERROR(
+        WErrors.IsValidU8,
+        `sharing GuardIdentifier: ${sharing2.who.GuardIdentifier}`
+      );
+    }
+    return tx.moveCall({
+      target: allocationFn("sharing_for_guard_identifier"),
+      arguments: [
+        tx.pure.u8(sharing2.who.GuardIdentifier),
+        tx.pure.u64(sharing2.sharing),
+        tx.pure.u8(Number(sharing2.mode))
+      ]
+    });
+  } else if ("Entity" in sharing2.who) {
+    const addr = preResolvedAddress || await GetAccountOrMark_Address(sharing2.who.Entity);
+    if (!addr) {
+      W_ERROR(
+        WErrors.IsValidAddress,
+        `sharing Entity: ${sharing2.who.Entity}`
+      );
+    }
+    return tx.moveCall({
+      target: allocationFn("sharing_for_address"),
+      arguments: [
+        tx.pure.address(addr),
+        tx.pure.u64(sharing2.sharing),
+        tx.pure.u8(Number(sharing2.mode))
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: allocationFn("sharing_for_signer"),
+      arguments: [
+        tx.pure.u64(sharing2.sharing),
+        tx.pure.u8(Number(sharing2.mode))
+      ]
+    });
+  }
+};
+const allocators = async (tx, param) => {
+  if (!isValidDescription(param.description)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (param.allocators.length > MAX_ALLOCATOR_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Allocator count exceeds maximum limit ${MAX_ALLOCATOR_COUNT}`
+    );
+  }
+  if (param.allocators.length === 0) {
+    W_ERROR(WErrors.InvalidParam, `Allocator array cannot be empty`);
+  }
+  if (!isValidU64(param.threshold)) {
+    W_ERROR(WErrors.InvalidParam, `threshold: ${param.threshold}`);
+  }
+  const allocators_obj = tx.moveCall({
+    target: allocationFn("allocators"),
+    arguments: [
+      tx.pure.string(param.description),
+      tx.pure.u64(param.threshold)
+    ]
+  });
+  for (let i = 0; i < param.allocators.length; i++) {
+    const allocator = param.allocators[i];
+    if (allocator.sharing.length === 0) {
+      W_ERROR(WErrors.InvalidParam, `sharing array cannot be empty`);
+    }
+    if (allocator.sharing.length > MAX_SHARING_COUNT) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `sharing count exceeds maximum limit ${MAX_SHARING_COUNT}`
+      );
+    }
+    const entityItems = allocator.sharing.map((s, index) => {
+      if ("Entity" in s.who) {
+        return {
+          index,
+          name_or_address: s.who.Entity.name_or_address
+        };
+      } else {
+        return null;
+      }
+    }).filter(
+      (item) => item !== null
+    );
+    const [g, entityAddrs] = await Promise.all([
+      LocalMark.Instance().get_address(allocator.guard),
+      // 只转换 Entity 类型
+      GetManyAccountOrMark_Address({
+        entities: entityItems,
+        check_all_founded: true
+      })
+    ]);
+    const addrs = new Array(allocator.sharing.length);
+    entityItems.forEach((item, entityIndex) => {
+      addrs[item.index] = entityAddrs[entityIndex];
+    });
+    if (!g) {
+      W_ERROR(WErrors.IsValidAddress, `guard: ${allocator.guard}`);
+    }
+    const sharingElements = await Promise.all(
+      allocator.sharing.map(async (s, index) => {
+        if ("Entity" in s.who) {
+          const addr = addrs[index];
+          if (!addr) {
+            W_ERROR(
+              WErrors.IsValidAddress,
+              `entity: ${typeof s.who.Entity === "string" ? s.who.Entity : s.who.Entity.name_or_address}`
+            );
+          }
+          return sharing(tx, s, addr);
+        } else {
+          return sharing(tx, s);
+        }
+      })
+    );
+    const makeMoveVecResult = tx.makeMoveVec({
+      elements: sharingElements,
+      type: `${PackageAddress}::allocation::Sharing`
+      //@ must specify type
+    });
+    tx.moveCall({
+      target: allocationFn("allocator_add"),
+      arguments: [
+        allocators_obj,
+        toTxObject(tx, g),
+        makeMoveVecResult,
+        tx.pure.option("u64", allocator?.max)
+      ]
+    });
+  }
+  return allocators_obj;
+};
+function alloc(tx, allocation, allocation_type, guard, passport) {
+  validObjects([allocation, guard, passport]);
+  if (!IsValidArgType(allocation_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `allocation_type: ${allocation_type} invalid`
+    );
+  }
+  tx.moveCall({
+    target: allocationFn("alloc"),
+    arguments: [
+      allocation,
+      toTxObject(tx, guard),
+      toTxObject(tx, passport),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ],
+    typeArguments: [allocation_type]
+  });
+}
+function newAllocation(tx, allocation_type, coin, allocators2) {
+  validObjects([coin, allocators2]);
+  return tx.moveCall({
+    target: allocationFn("new_with_coin"),
+    arguments: [
+      coin,
+      allocators2,
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ],
+    typeArguments: [allocation_type]
+  });
+}
+function create(tx, allocation, allocation_type, paymentInfo2) {
+  validObjects([allocation, paymentInfo2]);
+  if (!IsValidArgType(allocation_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `allocation_type: ${allocation_type} invalid`
+    );
+  }
+  return tx.moveCall({
+    target: allocationFn("create"),
+    arguments: [allocation, toTxObject(tx, paymentInfo2)],
+    typeArguments: [allocation_type]
+  });
+}
+function receive(tx, allocation, allocation_type, received, payment) {
+  validObjects([allocation, payment, received]);
+  if (!IsValidArgType(allocation_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `allocation_type: ${allocation_type} invalid`
+    );
+  }
+  return tx.moveCall({
+    target: allocationFn("receive"),
+    arguments: [
+      allocation,
+      toTxObject(tx, received),
+      toTxObject(tx, payment)
+    ],
+    typeArguments: [allocation_type]
+  });
+}
+export {
+  CallAllocation,
+  MAX_ALLOCATOR_COUNT,
+  MAX_SHARING_COUNT,
+  alloc,
+  allocationFn,
+  allocators,
+  create,
+  newAllocation,
+  receive,
+  sharing
+};

package/dist/esm/w/call/arb.d.ts

@@ -0,0 +1,17 @@
+import type { Transaction } from "../../transactions/index.js";
+import type { ArbObject, ArbAddress, OrderObject } from "../common.js";
+export declare function arbFn(name: string): string;
+export declare const MAX_PROPOSITION_COUNT = 20;
+export declare const MAX_VOTOR_COUNT = 520;
+export declare const WITHDRAW_DURATION_TIME = 2592000000;
+export interface ArbEvent {
+    object: string;
+    arbitration: string;
+    order: string;
+    status: number;
+}
+export declare function create(tx: Transaction, arb: ArbObject, arb_type: string): ArbAddress;
+export declare function proposition_change(tx: Transaction, arb: ArbObject, arb_type: string, order: OrderObject, proposition: string[], description: string | null | undefined, principal_confirmed: boolean): void;
+export declare function description_change(tx: Transaction, arb: ArbObject, arb_type: string, order: OrderObject, discription: string, principal_confirmed: boolean): void;
+export declare function principal_confirm(tx: Transaction, arb: ArbObject, arb_type: string, order: OrderObject, confirmed: boolean): void;
+export declare function objection(tx: Transaction, arb: ArbObject, arb_type: string, order: OrderObject, objection: string): void;

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

@@ -0,0 +1,138 @@
+import {
+  toTxObject,
+  isValidDescription,
+  MAX_DESCRIPTION_LENGTH,
+  isValidLongName,
+  PackageAddress,
+  MAX_LONG_NAME_LENGTH,
+  isValidArray,
+  IsValidArgType
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { validObjects } from "../util.js";
+function arbFn(name) {
+  return `${PackageAddress}::arb::${name}`;
+}
+const MAX_PROPOSITION_COUNT = 20;
+const MAX_VOTOR_COUNT = 520;
+const WITHDRAW_DURATION_TIME = 2592e6;
+function create(tx, arb, arb_type) {
+  validObjects([arb]);
+  if (!IsValidArgType(arb_type)) {
+    W_ERROR(WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  return tx.moveCall({
+    target: arbFn("create"),
+    arguments: [toTxObject(tx, arb)],
+    typeArguments: [arb_type]
+  });
+}
+function proposition_change(tx, arb, arb_type, order, proposition, description, principal_confirmed) {
+  validObjects([arb, order]);
+  if (!IsValidArgType(arb_type)) {
+    W_ERROR(WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  if (!isValidArray(proposition, (item) => {
+    if (!isValidLongName(item)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Proposition name ${item} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+      );
+    }
+    return true;
+  })) {
+    W_ERROR(WErrors.InvalidParam, "Proposition is not valid");
+  }
+  if (proposition.length > MAX_PROPOSITION_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Proposition count exceeds maximum count ${MAX_PROPOSITION_COUNT}`
+    );
+  }
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: arbFn("proposition_change"),
+    arguments: [
+      toTxObject(tx, arb),
+      toTxObject(tx, order),
+      tx.pure.vector("string", proposition),
+      tx.pure.option("string", description ?? null),
+      tx.pure.bool(principal_confirmed)
+    ],
+    typeArguments: [arb_type]
+  });
+}
+function description_change(tx, arb, arb_type, order, discription, principal_confirmed) {
+  validObjects([arb, order]);
+  if (!IsValidArgType(arb_type)) {
+    W_ERROR(WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  if (typeof discription === "string" && !isValidDescription(discription)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: arbFn("description_change"),
+    arguments: [
+      toTxObject(tx, arb),
+      toTxObject(tx, order),
+      tx.pure.string(discription),
+      tx.pure.bool(principal_confirmed)
+    ],
+    typeArguments: [arb_type]
+  });
+}
+function principal_confirm(tx, arb, arb_type, order, confirmed) {
+  validObjects([arb, order]);
+  if (!IsValidArgType(arb_type)) {
+    W_ERROR(WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  tx.moveCall({
+    target: arbFn("principal_confirm"),
+    arguments: [
+      toTxObject(tx, arb),
+      toTxObject(tx, order),
+      tx.pure.bool(confirmed)
+    ],
+    typeArguments: [arb_type]
+  });
+}
+function objection(tx, arb, arb_type, order, objection2) {
+  validObjects([arb, order]);
+  if (!IsValidArgType(arb_type)) {
+    W_ERROR(WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  if (typeof objection2 === "string" && !isValidDescription(objection2)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Objection exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: arbFn("objection"),
+    arguments: [
+      toTxObject(tx, arb),
+      toTxObject(tx, order),
+      tx.pure.string(objection2)
+    ],
+    typeArguments: [arb_type]
+  });
+}
+export {
+  MAX_PROPOSITION_COUNT,
+  MAX_VOTOR_COUNT,
+  WITHDRAW_DURATION_TIME,
+  arbFn,
+  create,
+  description_change,
+  objection,
+  principal_confirm,
+  proposition_change
+};

package/dist/esm/w/call/arbitration.d.ts

@@ -0,0 +1,106 @@
+import type { Transaction } from "../../transactions/index.js";
+import type { CallEnv, PassportObject, CoinParam, TypedPermissionObject, PermissionObject, ArbitrationObject, ArbitrationAddress, BalanceType, ArbObject, NamedObject, PaymentAddress } from "../common.js";
+import type { VotingGuard } from "../query/object.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+import type { ReceivedObjectsOrRecently } from "../query/received.js";
+export interface CallArbitration_Data {
+    object: TypedPermissionObject;
+    dispute?: {
+        order: string;
+        description: string;
+        proposition: string[];
+        fee: CoinParam;
+        namedArb?: NamedObject;
+    };
+    description?: string;
+    location?: string;
+    fee?: BalanceType;
+    pause?: boolean;
+    confirm?: {
+        arb: string;
+        voting_deadline: number | null;
+    };
+    voting_deadline_change?: {
+        arb: string;
+        voting_deadline: number | null;
+    };
+    vote?: {
+        arb: string;
+        votes: number[];
+        voting_guard?: string;
+    };
+    feedback?: {
+        arb: string;
+        feedback: string;
+    };
+    arbitration?: {
+        arb: string;
+        feedback: string;
+        indemnity: number;
+    };
+    reset?: {
+        arb: string;
+        feedback: string;
+    };
+    arb_withdraw?: {
+        arb: string;
+    };
+    fees_transfer?: {
+        to: {
+            allocation: string;
+        } | {
+            treasury: string;
+        };
+        payment_remark: string;
+        payment_index: number;
+        newPayment?: NamedObject;
+    };
+    usage_guard?: string | null;
+    voting_guard?: {
+        op: "add" | "set";
+        guards: VotingGuard[];
+    } | {
+        op: "remove";
+        guards: string[];
+    } | {
+        op: "clear";
+    };
+    owner_receive?: ReceivedObjectsOrRecently;
+    um?: string | null;
+}
+export declare class CallArbitration extends CallBase {
+    data: CallArbitration_Data;
+    object_address: string | undefined;
+    permission_address: string | undefined;
+    new_permission_description: string | undefined;
+    parameter_type: string | undefined;
+    constructor(data: CallArbitration_Data);
+    protected prepare(env: CallEnv): Promise<void>;
+    call(env: CallEnv): Promise<CallResult>;
+    operate(env: CallEnv, tx: Transaction, passport?: PassportObject, submission?: GuardSubmissionToFill[]): Promise<void>;
+}
+export declare const MAX_VOTING_GUARD_COUNT = 50;
+export declare function create(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string): ArbitrationAddress;
+export declare function newArbitration(tx: Transaction, parameter_type: string, permission: PermissionObject, description: string, passport?: PassportObject): ArbitrationObject;
+export declare function description_set(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, description: string, passport?: PassportObject): void;
+export declare function location_set(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, location: string, passport?: PassportObject): void;
+export declare function voting_guard_add(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, voting_guards: VotingGuard[], passport?: PassportObject): void;
+export declare function voting_guard_remove(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, guards: string[], passport?: PassportObject): void;
+export declare function voting_guard_clear(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, passport?: PassportObject): void;
+export declare function usage_guard_set(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, guard: string, passport?: PassportObject): void;
+export declare function usage_guard_none(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, passport?: PassportObject): void;
+export declare function pause(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, pause: boolean, passport?: PassportObject): void;
+export declare function fee_set(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, fee: BalanceType, passport?: PassportObject): void;
+export declare function dispute(env: CallEnv, tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, order: string, description: string, proposition: string[], fee: CoinParam, passport?: PassportObject): Promise<ArbObject>;
+export declare function vote(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, votes: number[], voting_guard?: string, passport?: PassportObject): void;
+export declare function arbitration(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, feedback: string, indemnity: BalanceType, passport?: PassportObject): void;
+export declare function feedback(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, feedback: string, passport?: PassportObject): void;
+export declare function confirm(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, voting_deadline: number | null, passport?: PassportObject): void;
+export declare function voting_deadline_change(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, voting_deadline: number | null, passport?: PassportObject): void;
+export declare function reset(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, feedback: string, passport?: PassportObject): void;
+export declare function arb_withdraw(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, arb: string, passport?: PassportObject): void;
+export declare function fees_alloc(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, allocation: string, payment_remark: string, payment_index: number, passport?: PassportObject): PaymentAddress;
+export declare function fees_transfer(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, treasury: string, payment_remark: string, payment_index: number, passport?: PassportObject): PaymentAddress;
+export declare function um_set(tx: Transaction, arbitration: ArbitrationObject, parameter_type: string, permission: PermissionObject, um: string | null, passport?: PassportObject): void;