wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,439 @@
+"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 allocation_exports = {};
+__export(allocation_exports, {
+  CallAllocation: () => CallAllocation,
+  MAX_ALLOCATOR_COUNT: () => MAX_ALLOCATOR_COUNT,
+  MAX_SHARING_COUNT: () => MAX_SHARING_COUNT,
+  alloc: () => alloc,
+  allocationFn: () => allocationFn,
+  allocators: () => allocators,
+  create: () => create,
+  newAllocation: () => newAllocation,
+  receive: () => receive,
+  sharing: () => sharing
+});
+module.exports = __toCommonJS(allocation_exports);
+var import_sui_types = require("../../utils/sui-types.js");
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_local = require("../local/index.js");
+var import_local2 = require("../local/local.js");
+var import_object = require("../query/object.js");
+var import_received = require("../query/received.js");
+var import_util = require("../util.js");
+var import_base = require("./base.js");
+var import_passport = require("./passport.js");
+var import_payment = require("./payment.js");
+class CallAllocation extends import_base.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 (0, import_common.GetObjectExisted)(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        import_object.ObjectType.Allocation,
+        this.object_address
+      );
+      if (!this.content) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallAllocation_Data.data.object:" + this.object_address
+        );
+      }
+      this.type_parameter = (0, import_util.parseObjectType)(
+        this.content.type_raw,
+        "allocation::Allocation"
+      );
+      if (!this.type_parameter) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidArgType,
+          "CallAllocation_Data.data.object.type_parameter is empty"
+        );
+      }
+    } else {
+      const n = (0, import_common.GetObject)(this.data.object);
+      if (!n || !(0, import_common.IsValidArgType)(n?.type_parameter)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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 import_local2.LocalMark.Instance().get_address(
+        this.data.alloc_by_guard
+      );
+      if (!g || !(0, import_sui_types.isValidWowAddress)(g)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidAddress,
+          `alloc_by_guard: ${this.data.alloc_by_guard}`
+        );
+      }
+      if (this.content && !this.content.allocators.find(
+        (item) => item.guard === g
+      )) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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 (0, import_passport.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 (0, import_received.query_received)({
+            object: this.object_address,
+            network: env.network,
+            no_cache: env.no_cache
+          });
+          if (Array.isArray(received)) {
+            (0, import_exception.W_ERROR)(
+              import_exception.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.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 (!(0, import_sui_types.isValidWowAddress)(v.id) || !(0, import_sui_types.isValidWowAddress)(v.payment)) {
+              (0, import_exception.W_ERROR)(
+                import_exception.WErrors.InvalidParam,
+                "CallAllocation_Data.data.received_coins:" + v.id
+              );
+            }
+            receive(
+              tx,
+              (0, import_common.toTxObject)(tx, this.object_address),
+              this.type_parameter,
+              (0, import_common.toTxObject)(tx, v.id),
+              (0, import_common.toTxObject)(tx, v.payment)
+            );
+          }
+        }
+      }
+      if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
+        if (!passport) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            "CallAllocation_Data.data.alloc_by_guard:" + this.data.alloc_by_guard
+          );
+        }
+        alloc(
+          tx,
+          (0, import_common.toTxObject)(tx, this.object_address),
+          this.type_parameter,
+          this.data.alloc_by_guard,
+          passport
+        );
+      }
+    } else {
+      const n = (0, import_common.GetObject)(this.data.object);
+      if (!(0, import_common.IsValidArgType)(n?.type_parameter)) {
+        (0, import_exception.W_ERROR)(
+          import_exception.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 (0, import_base.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,
+          import_object.ObjectType.Allocation,
+          create(
+            tx,
+            allocation,
+            this.type_parameter,
+            await (0, import_payment.paymentInfo)(env, tx, this.data.payment_info)
+          ),
+          n
+        );
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `CallAllocation_Data.data ${JSON.stringify(this.data)}`
+        );
+      }
+    }
+  }
+}
+function allocationFn(name) {
+  return `${import_common.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 (!(0, import_common.isValidU8)(sharing2.who.GuardIdentifier)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.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 (0, import_local.GetAccountOrMark_Address)(sharing2.who.Entity);
+    if (!addr) {
+      (0, import_exception.W_ERROR)(
+        import_exception.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 (!(0, import_common.isValidDescription)(param.description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (param.allocators.length > MAX_ALLOCATOR_COUNT) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Allocator count exceeds maximum limit ${MAX_ALLOCATOR_COUNT}`
+    );
+  }
+  if (param.allocators.length === 0) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Allocator array cannot be empty`);
+  }
+  if (!(0, import_common.isValidU64)(param.threshold)) {
+    (0, import_exception.W_ERROR)(import_exception.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) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `sharing array cannot be empty`);
+    }
+    if (allocator.sharing.length > MAX_SHARING_COUNT) {
+      (0, import_exception.W_ERROR)(
+        import_exception.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([
+      import_local2.LocalMark.Instance().get_address(allocator.guard),
+      // 只转换 Entity 类型
+      (0, import_local.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) {
+      (0, import_exception.W_ERROR)(import_exception.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) {
+            (0, import_exception.W_ERROR)(
+              import_exception.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: `${import_common.PackageAddress}::allocation::Sharing`
+      //@ must specify type
+    });
+    tx.moveCall({
+      target: allocationFn("allocator_add"),
+      arguments: [
+        allocators_obj,
+        (0, import_common.toTxObject)(tx, g),
+        makeMoveVecResult,
+        tx.pure.option("u64", allocator?.max)
+      ]
+    });
+  }
+  return allocators_obj;
+};
+function alloc(tx, allocation, allocation_type, guard, passport) {
+  (0, import_util.validObjects)([allocation, guard, passport]);
+  if (!(0, import_common.IsValidArgType)(allocation_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `allocation_type: ${allocation_type} invalid`
+    );
+  }
+  tx.moveCall({
+    target: allocationFn("alloc"),
+    arguments: [
+      allocation,
+      (0, import_common.toTxObject)(tx, guard),
+      (0, import_common.toTxObject)(tx, passport),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ],
+    typeArguments: [allocation_type]
+  });
+}
+function newAllocation(tx, allocation_type, coin, allocators2) {
+  (0, import_util.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) {
+  (0, import_util.validObjects)([allocation, paymentInfo2]);
+  if (!(0, import_common.IsValidArgType)(allocation_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `allocation_type: ${allocation_type} invalid`
+    );
+  }
+  return tx.moveCall({
+    target: allocationFn("create"),
+    arguments: [allocation, (0, import_common.toTxObject)(tx, paymentInfo2)],
+    typeArguments: [allocation_type]
+  });
+}
+function receive(tx, allocation, allocation_type, received, payment) {
+  (0, import_util.validObjects)([allocation, payment, received]);
+  if (!(0, import_common.IsValidArgType)(allocation_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `allocation_type: ${allocation_type} invalid`
+    );
+  }
+  return tx.moveCall({
+    target: allocationFn("receive"),
+    arguments: [
+      allocation,
+      (0, import_common.toTxObject)(tx, received),
+      (0, import_common.toTxObject)(tx, payment)
+    ],
+    typeArguments: [allocation_type]
+  });
+}

package/dist/cjs/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/cjs/w/call/arb.js

@@ -0,0 +1,149 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 arb_exports = {};
+__export(arb_exports, {
+  MAX_PROPOSITION_COUNT: () => MAX_PROPOSITION_COUNT,
+  MAX_VOTOR_COUNT: () => MAX_VOTOR_COUNT,
+  WITHDRAW_DURATION_TIME: () => WITHDRAW_DURATION_TIME,
+  arbFn: () => arbFn,
+  create: () => create,
+  description_change: () => description_change,
+  objection: () => objection,
+  principal_confirm: () => principal_confirm,
+  proposition_change: () => proposition_change
+});
+module.exports = __toCommonJS(arb_exports);
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_util = require("../util.js");
+function arbFn(name) {
+  return `${import_common.PackageAddress}::arb::${name}`;
+}
+const MAX_PROPOSITION_COUNT = 20;
+const MAX_VOTOR_COUNT = 520;
+const WITHDRAW_DURATION_TIME = 2592e6;
+function create(tx, arb, arb_type) {
+  (0, import_util.validObjects)([arb]);
+  if (!(0, import_common.IsValidArgType)(arb_type)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  return tx.moveCall({
+    target: arbFn("create"),
+    arguments: [(0, import_common.toTxObject)(tx, arb)],
+    typeArguments: [arb_type]
+  });
+}
+function proposition_change(tx, arb, arb_type, order, proposition, description, principal_confirmed) {
+  (0, import_util.validObjects)([arb, order]);
+  if (!(0, import_common.IsValidArgType)(arb_type)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  if (!(0, import_common.isValidArray)(proposition, (item) => {
+    if (!(0, import_common.isValidLongName)(item)) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Proposition name ${item} exceeds maximum length ${import_common.MAX_LONG_NAME_LENGTH}`
+      );
+    }
+    return true;
+  })) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "Proposition is not valid");
+  }
+  if (proposition.length > MAX_PROPOSITION_COUNT) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Proposition count exceeds maximum count ${MAX_PROPOSITION_COUNT}`
+    );
+  }
+  if (typeof description === "string" && !(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: arbFn("proposition_change"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, arb),
+      (0, import_common.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) {
+  (0, import_util.validObjects)([arb, order]);
+  if (!(0, import_common.IsValidArgType)(arb_type)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  if (typeof discription === "string" && !(0, import_common.isValidDescription)(discription)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: arbFn("description_change"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, arb),
+      (0, import_common.toTxObject)(tx, order),
+      tx.pure.string(discription),
+      tx.pure.bool(principal_confirmed)
+    ],
+    typeArguments: [arb_type]
+  });
+}
+function principal_confirm(tx, arb, arb_type, order, confirmed) {
+  (0, import_util.validObjects)([arb, order]);
+  if (!(0, import_common.IsValidArgType)(arb_type)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  tx.moveCall({
+    target: arbFn("principal_confirm"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, arb),
+      (0, import_common.toTxObject)(tx, order),
+      tx.pure.bool(confirmed)
+    ],
+    typeArguments: [arb_type]
+  });
+}
+function objection(tx, arb, arb_type, order, objection2) {
+  (0, import_util.validObjects)([arb, order]);
+  if (!(0, import_common.IsValidArgType)(arb_type)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Arb type ${arb_type} is not valid`);
+  }
+  if (typeof objection2 === "string" && !(0, import_common.isValidDescription)(objection2)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Objection exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: arbFn("objection"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, arb),
+      (0, import_common.toTxObject)(tx, order),
+      tx.pure.string(objection2)
+    ],
+    typeArguments: [arb_type]
+  });
+}