wowok 1.8.2 → 2.1.9

package/dist/esm/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/esm/w/call/order.js

@@ -0,0 +1,481 @@
+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 {
+  toTxObject,
+  PackageAddress,
+  GetObjectExisted,
+  IsValidArgType,
+  serviceFn
+} 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 { ArbStatus, ObjectType, query_objects } from "../query/object.js";
+import { query_received } from "../query/received.js";
+import { queryObjectWithType } from "../query/util.js";
+import { parseObjectType, validObjects } from "../util.js";
+import {
+  description_change,
+  MAX_PROPOSITION_COUNT,
+  objection,
+  principal_confirm,
+  proposition_change
+} from "./arb.js";
+import { CallBase } from "./base.js";
+import { accomplish, getMachineNodeForward, hold } from "./progress.js";
+class CallOrder extends 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 GetObjectExisted(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        ObjectType.Order,
+        this.object_address
+      );
+      if (!this.content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallOrder_Data.data.object:" + this.object_address
+        );
+      }
+    } else {
+      W_ERROR(
+        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) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallOrder_Data.data.progress error on progress not set"
+        );
+      }
+      const r = await query_objects({
+        objects: [orderObj.progress],
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (!r.objects || r.objects.length !== 1 || r.objects[0].type !== ObjectType.Progress) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallOrder_Data.data.progress fetch error"
+        );
+      }
+      const progressObj = r.objects[0];
+      const f = await 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 {
+        W_ERROR(
+          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 queryObjectWithType(
+        env,
+        this.content.service,
+        ObjectType.Service,
+        "service::Service"
+      );
+      if (s) {
+        this.service = {
+          object: s,
+          type: parseObjectType(
+            s.type_raw,
+            "service::Service"
+          )
+        };
+        if (!this.service.type) {
+          W_ERROR(
+            WErrors.IsValidArgType,
+            `CallOrder_Data.data.order_required_info error on service ${JSON.stringify(this.service.object)} type`
+          );
+        }
+      }
+    }
+    if (!this.service) {
+      W_ERROR(
+        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: toTxObject(tx, this.object_address),
+        agents: await GetManyAccountOrMark_Address(this.data.agent)
+      });
+    }
+    if (this.data.required_info !== void 0) {
+      await order_required_info_update(
+        tx,
+        toTxObject(tx, this.object_address),
+        this.data.required_info
+      );
+    }
+    if (this.data.progress != null) {
+      if (!content.machine) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallOrder_Data.data.progress fail with machine invalid for this order"
+        );
+      }
+      const r = await query_objects({
+        objects: [content.machine],
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (r.objects && r.objects.length === 1 && r.objects[0].type === ObjectType.Machine) {
+        const machine = r.objects[0];
+        if ("hold" in this.data.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 {
+          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 {
+        W_ERROR(
+          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, ArbStatus.Principal_confirming);
+      if (this.data.arb_confirm.proposition !== void 0) {
+        if (this.data.arb_confirm.proposition.length > MAX_PROPOSITION_COUNT) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallOrder_Data.data.arb_confirm.proposition length must be less than or equal to " + MAX_PROPOSITION_COUNT
+          );
+        }
+        proposition_change(
+          tx,
+          arb.object.object,
+          arb.type,
+          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) {
+        description_change(
+          tx,
+          arb.object.object,
+          arb.type,
+          toTxObject(tx, this.object_address),
+          this.data.arb_confirm.description,
+          this.data.arb_confirm.confirm
+        );
+      } else {
+        principal_confirm(
+          tx,
+          arb.object.object,
+          arb.type,
+          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, ArbStatus.Arbitrated);
+      objection(
+        tx,
+        arb.object.object,
+        arb.type,
+        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, 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: 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 query_received({
+          object: this.object_address,
+          all_type: true,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      }
+      await owner_receive(
+        tx,
+        toTxObject(tx, this.object_address),
+        this.data.receive
+      );
+    }
+    if (this.data.transfer_to != null) {
+      await owner_change(tx, {
+        order: toTxObject(tx, this.object_address),
+        new_owner: this.data.transfer_to
+      });
+    }
+  }
+  async get_arb(env, arb_address) {
+    const arb = await queryObjectWithType(
+      env,
+      arb_address,
+      ObjectType.Arb,
+      "arb::Arb"
+    );
+    if (!arb) {
+      W_ERROR(WErrors.InvalidParam, `Arb ${arb_address} not found`);
+    }
+    const arb_data = arb;
+    const ty = parseObjectType(arb_data.type_raw, "arb::Arb");
+    if (!ty) {
+      W_ERROR(
+        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) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `arb ${arb.object.object} status ${arb.object.status} not ${status}`
+      );
+    }
+    if (arb.object.order !== this.object_address) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `arb ${arb.object.object} order ${arb.object.order} not ${this.object_address}`
+      );
+    }
+    if (order.claimed_by) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `arb ${arb.object.object} error on order ${this.object_address} already disputed by ${order.claimed_by}`
+      );
+    }
+  }
+}
+function orderFn(name) {
+  return `${PackageAddress}::order::${name}`;
+}
+const MAX_AGENT_COUNT = 10;
+const MAX_DISPUTE_COUNT = 10;
+function create(tx, order) {
+  validObjects([order]);
+  return tx.moveCall({
+    target: orderFn("create"),
+    arguments: [toTxObject(tx, order)]
+  });
+}
+async function owner_change(tx, param) {
+  const new_owner = await GetAccountOrMark_Address(param.new_owner);
+  if (!new_owner) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `CallOrder_Data.data.new_owner:${param.new_owner}`
+    );
+  }
+  validObjects([param.order]);
+  tx.moveCall({
+    target: orderFn("owner_change"),
+    arguments: [toTxObject(tx, param.order), tx.pure.address(new_owner)]
+  });
+}
+function agent_set(tx, param) {
+  validObjects([param.order, ...param.agents]);
+  tx.moveCall({
+    target: orderFn("agent_set"),
+    arguments: [
+      toTxObject(tx, param.order),
+      tx.pure.vector("address", param.agents)
+    ]
+  });
+}
+async function owner_receive(tx, order, param) {
+  validObjects([order]);
+  if (Array.isArray(param)) {
+    for (const item of param) {
+      if (!item.type || !IsValidArgType(item.type)) {
+        W_ERROR(WErrors.IsValidArgType, `type ${item.type} is invalid`);
+      }
+      validObjects([item.id]);
+      tx.moveCall({
+        target: orderFn("owner_receive_object"),
+        arguments: [toTxObject(tx, order), toTxObject(tx, item.id)],
+        typeArguments: [item.type]
+      });
+    }
+  } else {
+    const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
+    if (!match) {
+      W_ERROR(
+        WErrors.IsValidArgType,
+        `Invalid CoinWrapper type: ${param.token_type}`
+      );
+    }
+    const t = match[1];
+    if (!IsValidArgType(t)) {
+      W_ERROR(WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+    }
+    for (const item of param.received) {
+      const [r, p] = await Promise.all([
+        LocalMark.Instance().get_address(item.id),
+        LocalMark.Instance().get_address(item.payment)
+      ]);
+      if (!r || !p) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          `Received ${item.id} or Payment ${item.payment} is invalid`
+        );
+      }
+      tx.moveCall({
+        target: orderFn("owner_receive"),
+        arguments: [
+          toTxObject(tx, order),
+          toTxObject(tx, r),
+          toTxObject(tx, p)
+        ],
+        typeArguments: [t]
+      });
+    }
+  }
+}
+async function order_required_info_update(tx, order, im_or_proof) {
+  validObjects([order]);
+  if (im_or_proof !== void 0) {
+    im_or_proof = await LocalMark.Instance().get_address(im_or_proof) ?? null;
+    if (!im_or_proof) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `CallOrder_Data.data.required_info ${im_or_proof} not found`
+      );
+    }
+  }
+  tx.moveCall({
+    target: orderFn("required_info_update"),
+    arguments: [
+      toTxObject(tx, order),
+      tx.pure.option("address", im_or_proof)
+    ]
+  });
+}
+function compensation_claim(tx, param) {
+  if (!IsValidArgType(param.service_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation claim service type ${param.service_type} is not valid`
+    );
+  }
+  if (!IsValidArgType(param.arbitration_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Compensation claim arbitration type ${param.arbitration_type} is not valid`
+    );
+  }
+  validObjects([
+    param.service,
+    param.arbitration_object,
+    param.order,
+    param.arb
+  ]);
+  tx.moveCall({
+    target: serviceFn("compensation_claim"),
+    arguments: [
+      toTxObject(tx, param.service),
+      toTxObject(tx, param.arbitration_object),
+      toTxObject(tx, param.order),
+      toTxObject(tx, param.arb),
+      tx.object.clock()
+    ],
+    typeArguments: [param.service_type, param.arbitration_type]
+  });
+}
+export {
+  CallOrder,
+  MAX_AGENT_COUNT,
+  MAX_DISPUTE_COUNT,
+  agent_set,
+  compensation_claim,
+  create,
+  orderFn,
+  order_required_info_update,
+  owner_change,
+  owner_receive
+};

package/dist/esm/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;