wowok 1.8.2 → 2.1.9

package/dist/cjs/w/call/order.d.ts

@@ -0,0 +1,73 @@
+import type { Transaction } from "../../transactions/index.js";
+import type { CallEnv, OrderAddress, OrderObject, PassportObject } from "../common.js";
+import type { AccountOrMark_Address, ManyAccountOrMark_Address } from "../local/index.js";
+import type { ObjectService } from "../query/object.js";
+import type { ReceivedObjects, ReceivedObjectsOrRecently } from "../query/received.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+import type { GuardSubmissionToFill } from "./guard.js";
+import type { ProgressNext } from "./progress.js";
+import type { CompensationClaim } from "./service.js";
+export interface CallOrder_Data {
+    object: string;
+    agent?: ManyAccountOrMark_Address;
+    required_info?: string | null;
+    progress?: {
+        operation: ProgressNext;
+        hold: boolean;
+        adminUnhold?: boolean;
+        message?: string;
+    } | {
+        operation: ProgressNext;
+        message?: string;
+    };
+    arb_confirm?: {
+        arb: string;
+        confirm: boolean;
+        description?: string;
+        proposition?: string[];
+    };
+    arb_objection?: {
+        arb: string;
+        objection: string;
+    };
+    arb_claim_compensation?: {
+        arb: string;
+    };
+    receive?: ReceivedObjectsOrRecently;
+    transfer_to?: AccountOrMark_Address;
+}
+interface ServiceInfo {
+    object: ObjectService;
+    type: string;
+}
+export declare class CallOrder extends CallBase {
+    data: CallOrder_Data;
+    object_address: string | undefined;
+    service: ServiceInfo | undefined;
+    constructor(data: CallOrder_Data);
+    protected prepare(env: CallEnv): Promise<void>;
+    call(env: CallEnv): Promise<CallResult>;
+    private get_service;
+    operate(env: CallEnv, tx: Transaction, _passport?: PassportObject, _submission?: GuardSubmissionToFill[]): Promise<void>;
+    private get_arb;
+    private check_arb;
+}
+export declare function orderFn(name: string): string;
+export declare const MAX_AGENT_COUNT = 10;
+export declare const MAX_DISPUTE_COUNT = 10;
+export interface OwnerChange {
+    order: OrderObject;
+    new_owner: AccountOrMark_Address;
+}
+export interface AgentSet {
+    order: OrderObject;
+    agents: string[];
+}
+export declare function create(tx: Transaction, order: OrderObject): OrderAddress;
+export declare function owner_change(tx: Transaction, param: OwnerChange): Promise<void>;
+export declare function agent_set(tx: Transaction, param: AgentSet): void;
+export declare function owner_receive(tx: Transaction, order: OrderObject, param: ReceivedObjects): Promise<void | number>;
+export declare function order_required_info_update(tx: Transaction, order: OrderObject, im_or_proof: string | null | undefined): Promise<void>;
+export declare function compensation_claim(tx: Transaction, param: CompensationClaim): void;
+export {};

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

@@ -0,0 +1,485 @@
+"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 order_exports = {};
+__export(order_exports, {
+  CallOrder: () => CallOrder,
+  MAX_AGENT_COUNT: () => MAX_AGENT_COUNT,
+  MAX_DISPUTE_COUNT: () => MAX_DISPUTE_COUNT,
+  agent_set: () => agent_set,
+  compensation_claim: () => compensation_claim,
+  create: () => create,
+  orderFn: () => orderFn,
+  order_required_info_update: () => order_required_info_update,
+  owner_change: () => owner_change,
+  owner_receive: () => owner_receive
+});
+module.exports = __toCommonJS(order_exports);
+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("../query/util.js");
+var import_util2 = require("../util.js");
+var import_arb = require("./arb.js");
+var import_base = require("./base.js");
+var import_progress = require("./progress.js");
+class CallOrder extends import_base.CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "service");
+    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.Order,
+        this.object_address
+      );
+      if (!this.content) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallOrder_Data.data.object:" + this.object_address
+        );
+      }
+    } else {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        "CallOrder_Data.data.object:" + this.data?.object
+      );
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const guards = [];
+    const add_guard = (guard) => {
+      if (!guards.includes(guard)) {
+        guards.push(guard);
+      }
+    };
+    const orderObj = this.content;
+    if (this.data.progress != null) {
+      if (!orderObj.machine || !orderObj.progress) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallOrder_Data.data.progress error on progress not set"
+        );
+      }
+      const r = await (0, import_object.query_objects)({
+        objects: [orderObj.progress],
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (!r.objects || r.objects.length !== 1 || r.objects[0].type !== import_object.ObjectType.Progress) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallOrder_Data.data.progress fetch error"
+        );
+      }
+      const progressObj = r.objects[0];
+      const f = await (0, import_progress.getMachineNodeForward)(
+        env,
+        progressObj.machine,
+        progressObj.current,
+        this.data.progress.operation.next_node_name,
+        this.data.progress.operation.forward
+      );
+      if (f) {
+        if (f.guard) {
+          add_guard(f.guard.guard);
+        }
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `CallOrder_Data.data.progress.operation.forward:${this.data?.progress.operation.forward} not found`
+        );
+      }
+    }
+    if (guards.length > 0) {
+      return await this.check_guard_and_call(env, guards);
+    }
+    return await this.exec(env);
+  }
+  async get_service(env) {
+    if (!this.service && this.content) {
+      const s = await (0, import_util.queryObjectWithType)(
+        env,
+        this.content.service,
+        import_object.ObjectType.Service,
+        "service::Service"
+      );
+      if (s) {
+        this.service = {
+          object: s,
+          type: (0, import_util2.parseObjectType)(
+            s.type_raw,
+            "service::Service"
+          )
+        };
+        if (!this.service.type) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.IsValidArgType,
+            `CallOrder_Data.data.order_required_info error on service ${JSON.stringify(this.service.object)} type`
+          );
+        }
+      }
+    }
+    if (!this.service) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `CallOrder_Data.data.order_required_info error on service ${this.content.service}`
+      );
+    }
+    return this.service;
+  }
+  async operate(env, tx, _passport, _submission) {
+    const content = this.content;
+    if (this.data.agent != null) {
+      agent_set(tx, {
+        order: (0, import_common.toTxObject)(tx, this.object_address),
+        agents: await (0, import_local.GetManyAccountOrMark_Address)(this.data.agent)
+      });
+    }
+    if (this.data.required_info !== void 0) {
+      await order_required_info_update(
+        tx,
+        (0, import_common.toTxObject)(tx, this.object_address),
+        this.data.required_info
+      );
+    }
+    if (this.data.progress != null) {
+      if (!content.machine) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallOrder_Data.data.progress fail with machine invalid for this order"
+        );
+      }
+      const r = await (0, import_object.query_objects)({
+        objects: [content.machine],
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (r.objects && r.objects.length === 1 && r.objects[0].type === import_object.ObjectType.Machine) {
+        const machine = r.objects[0];
+        if ("hold" in this.data.progress) {
+          (0, import_progress.hold)(
+            tx,
+            this.object_address,
+            machine.object,
+            machine.permission,
+            this.data.progress.operation.next_node_name,
+            this.data.progress.operation.forward,
+            this.data.progress.message ?? "",
+            this.data.progress.hold,
+            this.object_address,
+            _passport
+          );
+        } else {
+          (0, import_progress.accomplish)(
+            tx,
+            this.object_address,
+            machine.object,
+            machine.permission,
+            this.data.progress.operation.next_node_name,
+            this.data.progress.operation.forward,
+            this.data.progress.message ?? "",
+            this.object_address,
+            _passport
+          );
+        }
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallOrder_Data.data.progress fail with machine invalid for this order"
+        );
+      }
+    }
+    if (this.data.arb_confirm != null) {
+      const arb = await this.get_arb(env, this.data.arb_confirm.arb);
+      this.check_arb(content, arb, import_object.ArbStatus.Principal_confirming);
+      if (this.data.arb_confirm.proposition !== void 0) {
+        if (this.data.arb_confirm.proposition.length > import_arb.MAX_PROPOSITION_COUNT) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            "CallOrder_Data.data.arb_confirm.proposition length must be less than or equal to " + import_arb.MAX_PROPOSITION_COUNT
+          );
+        }
+        (0, import_arb.proposition_change)(
+          tx,
+          arb.object.object,
+          arb.type,
+          (0, import_common.toTxObject)(tx, this.object_address),
+          this.data.arb_confirm.proposition,
+          this.data.arb_confirm.description,
+          this.data.arb_confirm.confirm
+        );
+      } else if (this.data.arb_confirm.description !== void 0) {
+        (0, import_arb.description_change)(
+          tx,
+          arb.object.object,
+          arb.type,
+          (0, import_common.toTxObject)(tx, this.object_address),
+          this.data.arb_confirm.description,
+          this.data.arb_confirm.confirm
+        );
+      } else {
+        (0, import_arb.principal_confirm)(
+          tx,
+          arb.object.object,
+          arb.type,
+          (0, import_common.toTxObject)(tx, this.object_address),
+          this.data.arb_confirm.confirm
+        );
+      }
+    }
+    if (this.data.arb_objection != null) {
+      const arb = await this.get_arb(env, this.data.arb_objection.arb);
+      this.check_arb(content, arb, import_object.ArbStatus.Arbitrated);
+      (0, import_arb.objection)(
+        tx,
+        arb.object.object,
+        arb.type,
+        (0, import_common.toTxObject)(tx, this.object_address),
+        this.data.arb_objection.objection
+      );
+    }
+    if (this.data.arb_claim_compensation) {
+      const arb = await this.get_arb(
+        env,
+        this.data.arb_claim_compensation.arb
+      );
+      this.check_arb(content, arb, import_object.ArbStatus.Arbitrated);
+      const service = await this.get_service(env);
+      compensation_claim(tx, {
+        service: service.object.object,
+        service_type: service.type,
+        arbitration_object: arb.object.arbitration,
+        arbitration_type: arb.type,
+        order: (0, import_common.toTxObject)(tx, this.object_address),
+        arb: arb.object.object
+      });
+    }
+    if (this.data.receive != null && this.object_address) {
+      if (this.data.receive === "recently") {
+        this.data.receive = await (0, import_received.query_received)({
+          object: this.object_address,
+          all_type: true,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      }
+      await owner_receive(
+        tx,
+        (0, import_common.toTxObject)(tx, this.object_address),
+        this.data.receive
+      );
+    }
+    if (this.data.transfer_to != null) {
+      await owner_change(tx, {
+        order: (0, import_common.toTxObject)(tx, this.object_address),
+        new_owner: this.data.transfer_to
+      });
+    }
+  }
+  async get_arb(env, arb_address) {
+    const arb = await (0, import_util.queryObjectWithType)(
+      env,
+      arb_address,
+      import_object.ObjectType.Arb,
+      "arb::Arb"
+    );
+    if (!arb) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Arb ${arb_address} not found`);
+    }
+    const arb_data = arb;
+    const ty = (0, import_util2.parseObjectType)(arb_data.type_raw, "arb::Arb");
+    if (!ty) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.IsValidArgType,
+        `Arb ${arb_address} type ${arb_data.type_raw} is not valid`
+      );
+    }
+    return { object: arb_data, type: ty };
+  }
+  check_arb(order, arb, status) {
+    if (arb.object.status !== status) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `arb ${arb.object.object} status ${arb.object.status} not ${status}`
+      );
+    }
+    if (arb.object.order !== this.object_address) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `arb ${arb.object.object} order ${arb.object.order} not ${this.object_address}`
+      );
+    }
+    if (order.claimed_by) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `arb ${arb.object.object} error on order ${this.object_address} already disputed by ${order.claimed_by}`
+      );
+    }
+  }
+}
+function orderFn(name) {
+  return `${import_common.PackageAddress}::order::${name}`;
+}
+const MAX_AGENT_COUNT = 10;
+const MAX_DISPUTE_COUNT = 10;
+function create(tx, order) {
+  (0, import_util2.validObjects)([order]);
+  return tx.moveCall({
+    target: orderFn("create"),
+    arguments: [(0, import_common.toTxObject)(tx, order)]
+  });
+}
+async function owner_change(tx, param) {
+  const new_owner = await (0, import_local.GetAccountOrMark_Address)(param.new_owner);
+  if (!new_owner) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `CallOrder_Data.data.new_owner:${param.new_owner}`
+    );
+  }
+  (0, import_util2.validObjects)([param.order]);
+  tx.moveCall({
+    target: orderFn("owner_change"),
+    arguments: [(0, import_common.toTxObject)(tx, param.order), tx.pure.address(new_owner)]
+  });
+}
+function agent_set(tx, param) {
+  (0, import_util2.validObjects)([param.order, ...param.agents]);
+  tx.moveCall({
+    target: orderFn("agent_set"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, param.order),
+      tx.pure.vector("address", param.agents)
+    ]
+  });
+}
+async function owner_receive(tx, order, param) {
+  (0, import_util2.validObjects)([order]);
+  if (Array.isArray(param)) {
+    for (const item of param) {
+      if (!item.type || !(0, import_common.IsValidArgType)(item.type)) {
+        (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidArgType, `type ${item.type} is invalid`);
+      }
+      (0, import_util2.validObjects)([item.id]);
+      tx.moveCall({
+        target: orderFn("owner_receive_object"),
+        arguments: [(0, import_common.toTxObject)(tx, order), (0, import_common.toTxObject)(tx, item.id)],
+        typeArguments: [item.type]
+      });
+    }
+  } else {
+    const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
+    if (!match) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.IsValidArgType,
+        `Invalid CoinWrapper type: ${param.token_type}`
+      );
+    }
+    const t = match[1];
+    if (!(0, import_common.IsValidArgType)(t)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+    }
+    for (const item of param.received) {
+      const [r, p] = await Promise.all([
+        import_local2.LocalMark.Instance().get_address(item.id),
+        import_local2.LocalMark.Instance().get_address(item.payment)
+      ]);
+      if (!r || !p) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.IsValidArgType,
+          `Received ${item.id} or Payment ${item.payment} is invalid`
+        );
+      }
+      tx.moveCall({
+        target: orderFn("owner_receive"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, order),
+          (0, import_common.toTxObject)(tx, r),
+          (0, import_common.toTxObject)(tx, p)
+        ],
+        typeArguments: [t]
+      });
+    }
+  }
+}
+async function order_required_info_update(tx, order, im_or_proof) {
+  (0, import_util2.validObjects)([order]);
+  if (im_or_proof !== void 0) {
+    im_or_proof = await import_local2.LocalMark.Instance().get_address(im_or_proof) ?? null;
+    if (!im_or_proof) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `CallOrder_Data.data.required_info ${im_or_proof} not found`
+      );
+    }
+  }
+  tx.moveCall({
+    target: orderFn("required_info_update"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, order),
+      tx.pure.option("address", im_or_proof)
+    ]
+  });
+}
+function compensation_claim(tx, param) {
+  if (!(0, import_common.IsValidArgType)(param.service_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation claim service type ${param.service_type} is not valid`
+    );
+  }
+  if (!(0, import_common.IsValidArgType)(param.arbitration_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `Compensation claim arbitration type ${param.arbitration_type} is not valid`
+    );
+  }
+  (0, import_util2.validObjects)([
+    param.service,
+    param.arbitration_object,
+    param.order,
+    param.arb
+  ]);
+  tx.moveCall({
+    target: (0, import_common.serviceFn)("compensation_claim"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, param.service),
+      (0, import_common.toTxObject)(tx, param.arbitration_object),
+      (0, import_common.toTxObject)(tx, param.order),
+      (0, import_common.toTxObject)(tx, param.arb),
+      tx.object.clock()
+    ],
+    typeArguments: [param.service_type, param.arbitration_type]
+  });
+}

package/dist/cjs/w/call/passport.d.ts

@@ -0,0 +1,24 @@
+import type { SuiTransactionBlockResponse } from "../../client/index.js";
+import type { TransactionResult } from "../../transactions/index.js";
+import { Transaction } from "../../transactions/index.js";
+import type { PassportObject, GuardObject, CallEnv } from "../common.js";
+import type { GuardSubmissionToFill, GuardTableItem } from "./guard.js";
+export declare const MAX_GUARD_COUNT_ONCE = 20;
+export interface SubmissionCall {
+    type: "submission";
+    guard: {
+        object: string;
+        impack: boolean;
+    }[];
+    submission: GuardSubmissionToFill[];
+}
+export declare const verify_guard: (env: CallEnv, guard_info: SubmissionCall) => Promise<SuiTransactionBlockResponse>;
+export declare const get_guardSubmissions: (env: CallEnv, guards: string[]) => Promise<SubmissionCall>;
+export declare function passportFn(name: string): string;
+export declare const MAX_GUARD_COUNT = 20;
+export declare function newPassport(tx: Transaction): PassportObject;
+export declare function freeze(tx: Transaction, passport: PassportObject): void;
+export declare function destroy(tx: Transaction, passport: PassportObject): void;
+export declare const guardAdd: (tx: Transaction, passport: PassportObject, guard: GuardObject, submission: GuardTableItem[], impack: boolean) => Promise<void>;
+export declare function guardClear(tx: Transaction, passport: PassportObject): void;
+export declare function verify(tx: Transaction, passport: PassportObject): TransactionResult;