wowok 2.1.10 → 2.1.13

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

@@ -1,485 +1,345 @@
 "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);
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DISPUTE_COUNT = exports.MAX_AGENT_COUNT = exports.CallOrder = void 0;
+exports.orderFn = orderFn;
+exports.create = create;
+exports.owner_change = owner_change;
+exports.agent_set = agent_set;
+exports.owner_receive = owner_receive;
+exports.order_required_info_update = order_required_info_update;
+exports.compensation_claim = compensation_claim;
+const common_js_1 = require("../common.js");
+const exception_js_1 = require("../exception.js");
+const index_js_1 = require("../local/index.js");
+const local_js_1 = require("../local/local.js");
+const object_js_1 = require("../query/object.js");
+const received_js_1 = require("../query/received.js");
+const util_js_1 = require("../query/util.js");
+const util_js_2 = require("../util.js");
+const arb_js_1 = require("./arb.js");
+const base_js_1 = require("./base.js");
+const progress_js_1 = require("./progress.js");
+class CallOrder extends base_js_1.CallBase {
+    data;
+    object_address = undefined;
+    service = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
     }
-    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);
+    async prepare(env) {
+        await super.prepare(env);
+        if (!this.object_address) {
+            this.object_address = await (0, common_js_1.GetObjectExisted)(this.data?.object);
+        }
+        if (this.object_address) {
+            await this.update_content(env, object_js_1.ObjectType.Order, this.object_address);
+            if (!this.content) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallOrder_Data.data.object:" + this.object_address);
+            }
+        }
+        else {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallOrder_Data.data.object:" + this.data?.object);
         }
-      } 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"
-          )
+    async call(env) {
+        await this.prepare(env); // prepare first.
+        const guards = [];
+        const add_guard = (guard) => {
+            if (!guards.includes(guard)) {
+                guards.push(guard);
+            }
         };
-        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`
-          );
+        const orderObj = this.content;
+        if (this.data.progress != null) {
+            if (!orderObj.machine || !orderObj.progress) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallOrder_Data.data.progress error on progress not set");
+            }
+            const r = await (0, object_js_1.query_objects)({
+                objects: [orderObj.progress],
+                no_cache: env.no_cache,
+                network: env.network,
+            });
+            if (!r.objects ||
+                r.objects.length !== 1 ||
+                r.objects[0].type !== object_js_1.ObjectType.Progress) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallOrder_Data.data.progress fetch error");
+            }
+            const progressObj = r.objects[0];
+            const f = await (0, progress_js_1.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, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallOrder_Data.data.progress.operation.forward:${this.data?.progress.operation.forward} not found`);
+            }
         }
-      }
-    }
-    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
-          );
+        if (guards.length > 0) {
+            return await this.check_guard_and_call(env, guards);
         }
-      } else {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallOrder_Data.data.progress fail with machine invalid for this order"
-        );
-      }
+        return await this.exec(env);
     }
-    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
-          );
+    async get_service(env) {
+        if (!this.service && this.content) {
+            const s = await (0, util_js_1.queryObjectWithType)(env, this.content.service, object_js_1.ObjectType.Service, "service::Service");
+            if (s) {
+                this.service = {
+                    object: s,
+                    type: (0, util_js_2.parseObjectType)(s.type_raw, "service::Service"),
+                };
+                if (!this.service.type) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `CallOrder_Data.data.order_required_info error on service ${JSON.stringify(this.service.object)} type`);
+                }
+            }
         }
-        (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`
-      );
+        if (!this.service) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallOrder_Data.data.order_required_info error on service ${this.content.service}`);
+        }
+        return this.service;
     }
-    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}`
-      );
+    async operate(env, tx, _passport, _submission) {
+        const content = this.content;
+        if (this.data.agent != null) {
+            agent_set(tx, {
+                order: (0, common_js_1.toTxObject)(tx, this.object_address),
+                agents: await (0, index_js_1.GetManyAccountOrMark_Address)(this.data.agent),
+            });
+        }
+        if (this.data.required_info !== undefined) {
+            await order_required_info_update(tx, (0, common_js_1.toTxObject)(tx, this.object_address), this.data.required_info);
+        }
+        if (this.data.progress != null) {
+            if (!content.machine) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallOrder_Data.data.progress fail with machine invalid for this order");
+            }
+            const r = await (0, object_js_1.query_objects)({
+                objects: [content.machine],
+                no_cache: env.no_cache,
+                network: env.network,
+            });
+            if (r.objects &&
+                r.objects.length === 1 &&
+                r.objects[0].type === object_js_1.ObjectType.Machine) {
+                const machine = r.objects[0];
+                if ("hold" in this.data.progress) {
+                    (0, progress_js_1.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, progress_js_1.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, exception_js_1.W_ERROR)(exception_js_1.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, object_js_1.ArbStatus.Principal_confirming);
+            if (this.data.arb_confirm.proposition !== undefined) {
+                if (this.data.arb_confirm.proposition.length >
+                    arb_js_1.MAX_PROPOSITION_COUNT) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallOrder_Data.data.arb_confirm.proposition length must be less than or equal to " +
+                        arb_js_1.MAX_PROPOSITION_COUNT);
+                }
+                (0, arb_js_1.proposition_change)(tx, arb.object.object, arb.type, (0, common_js_1.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 !== undefined) {
+                (0, arb_js_1.description_change)(tx, arb.object.object, arb.type, (0, common_js_1.toTxObject)(tx, this.object_address), this.data.arb_confirm.description, this.data.arb_confirm.confirm);
+            }
+            else {
+                (0, arb_js_1.principal_confirm)(tx, arb.object.object, arb.type, (0, common_js_1.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, object_js_1.ArbStatus.Arbitrated);
+            (0, arb_js_1.objection)(tx, arb.object.object, arb.type, (0, common_js_1.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, object_js_1.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, common_js_1.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, received_js_1.query_received)({
+                    object: this.object_address,
+                    all_type: true,
+                    no_cache: env.no_cache,
+                    network: env.network,
+                });
+            }
+            await owner_receive(tx, (0, common_js_1.toTxObject)(tx, this.object_address), this.data.receive);
+        }
+        if (this.data.transfer_to != null) {
+            await owner_change(tx, {
+                order: (0, common_js_1.toTxObject)(tx, this.object_address),
+                new_owner: this.data.transfer_to,
+            });
+        }
     }
-    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}`
-      );
+    async get_arb(env, arb_address) {
+        const arb = await (0, util_js_1.queryObjectWithType)(env, arb_address, object_js_1.ObjectType.Arb, "arb::Arb");
+        if (!arb) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Arb ${arb_address} not found`);
+        }
+        const arb_data = arb;
+        const ty = (0, util_js_2.parseObjectType)(arb_data.type_raw, "arb::Arb");
+        if (!ty) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Arb ${arb_address} type ${arb_data.type_raw} is not valid`);
+        }
+        return { object: arb_data, type: ty };
     }
-    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}`
-      );
+    check_arb(order, arb, status) {
+        if (arb.object.status !== status) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `arb ${arb.object.object} status ${arb.object.status} not ${status}`);
+        }
+        if (arb.object.order !== this.object_address) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `arb ${arb.object.object} order ${arb.object.order} not ${this.object_address}`);
+        }
+        if (order.claimed_by) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `arb ${arb.object.object} error on order ${this.object_address} already disputed by ${order.claimed_by}`);
+        }
     }
-  }
 }
+exports.CallOrder = CallOrder;
+// ================================================
 function orderFn(name) {
-  return `${import_common.PackageAddress}::order::${name}`;
+    return `${common_js_1.PackageAddress}::order::${name}`;
 }
-const MAX_AGENT_COUNT = 10;
-const MAX_DISPUTE_COUNT = 10;
+// ================================================
+// 常量定义
+exports.MAX_AGENT_COUNT = 10;
+exports.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)]
-  });
+    (0, util_js_2.validObjects)([order]);
+    return tx.moveCall({
+        target: orderFn("create"),
+        arguments: [(0, common_js_1.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)]
-  });
+    const new_owner = await (0, index_js_1.GetAccountOrMark_Address)(param.new_owner);
+    if (!new_owner) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallOrder_Data.data.new_owner:${param.new_owner}`);
+    }
+    (0, util_js_2.validObjects)([param.order]);
+    tx.moveCall({
+        target: orderFn("owner_change"),
+        arguments: [(0, common_js_1.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)
-    ]
-  });
+    (0, util_js_2.validObjects)([param.order, ...param.agents]);
+    tx.moveCall({
+        target: orderFn("agent_set"),
+        arguments: [
+            (0, common_js_1.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}`);
+    (0, util_js_2.validObjects)([order]);
+    // 处理ReceivedNormal[]类型
+    if (Array.isArray(param)) {
+        for (const item of param) {
+            if (!item.type || !(0, common_js_1.IsValidArgType)(item.type)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `type ${item.type} is invalid`);
+            }
+            (0, util_js_2.validObjects)([item.id]);
+            tx.moveCall({
+                target: orderFn("owner_receive_object"),
+                arguments: [(0, common_js_1.toTxObject)(tx, order), (0, common_js_1.toTxObject)(tx, item.id)],
+                typeArguments: [item.type],
+            });
+        }
     }
-    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]
-      });
+    // 处理ReceivedBalance类型
+    else {
+        const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
+        if (!match) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${param.token_type}`);
+        }
+        const t = match[1];
+        if (!(0, common_js_1.IsValidArgType)(t)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+        }
+        for (const item of param.received) {
+            const [r, p] = await Promise.all([
+                local_js_1.LocalMark.Instance().get_address(item.id),
+                local_js_1.LocalMark.Instance().get_address(item.payment),
+            ]);
+            if (!r || !p) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Received ${item.id} or Payment ${item.payment} is invalid`);
+            }
+            // 这里假设item.id是CoinWrapper类型的对象
+            tx.moveCall({
+                target: orderFn("owner_receive"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, order),
+                    (0, common_js_1.toTxObject)(tx, r),
+                    (0, common_js_1.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`
-      );
+    (0, util_js_2.validObjects)([order]);
+    if (im_or_proof !== undefined) {
+        im_or_proof =
+            (await local_js_1.LocalMark.Instance().get_address(im_or_proof)) ?? null;
+        if (!im_or_proof) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.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)
-    ]
-  });
+    tx.moveCall({
+        target: orderFn("required_info_update"),
+        arguments: [
+            (0, common_js_1.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]
-  });
+    if (!(0, common_js_1.IsValidArgType)(param.service_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation claim service type ${param.service_type} is not valid`);
+    }
+    if (!(0, common_js_1.IsValidArgType)(param.arbitration_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Compensation claim arbitration type ${param.arbitration_type} is not valid`);
+    }
+    (0, util_js_2.validObjects)([
+        param.service,
+        param.arbitration_object,
+        param.order,
+        param.arb,
+    ]);
+    tx.moveCall({
+        target: (0, common_js_1.serviceFn)("compensation_claim"),
+        arguments: [
+            (0, common_js_1.toTxObject)(tx, param.service),
+            (0, common_js_1.toTxObject)(tx, param.arbitration_object),
+            (0, common_js_1.toTxObject)(tx, param.order),
+            (0, common_js_1.toTxObject)(tx, param.arb),
+            tx.object.clock(),
+        ],
+        typeArguments: [param.service_type, param.arbitration_type],
+    });
 }
+//# sourceMappingURL=order.js.map