wowok 2.1.10 → 2.1.13

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

@@ -1,481 +1,334 @@
-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";
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+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 { 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 { 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);
+export class CallOrder extends CallBase {
+    data;
+    object_address = undefined;
+    service = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
     }
-    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);
+    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);
         }
-      } 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"
-          )
+    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) {
-          W_ERROR(
-            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) {
+                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 (!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
-          );
+        if (guards.length > 0) {
+            return await this.check_guard_and_call(env, guards);
         }
-      } else {
-        W_ERROR(
-          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, 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
-          );
+    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`);
+                }
+            }
         }
-        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`
-      );
+        if (!this.service) {
+            W_ERROR(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) {
-      W_ERROR(
-        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: toTxObject(tx, this.object_address),
+                agents: await GetManyAccountOrMark_Address(this.data.agent),
+            });
+        }
+        if (this.data.required_info !== undefined) {
+            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 !== undefined) {
+                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 !== undefined) {
+                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,
+            });
+        }
     }
-    if (arb.object.order !== this.object_address) {
-      W_ERROR(
-        WErrors.InvalidParam,
-        `arb ${arb.object.object} order ${arb.object.order} not ${this.object_address}`
-      );
+    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 };
     }
-    if (order.claimed_by) {
-      W_ERROR(
-        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) {
+            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}`;
+// ================================================
+export 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)]
-  });
+// ================================================
+// 常量定义
+export const MAX_AGENT_COUNT = 10;
+export const MAX_DISPUTE_COUNT = 10;
+// ================================================
+// 公共函数调用
+export 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)]
-  });
+export 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)
-    ]
-  });
+export 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]
-      });
+export async function owner_receive(tx, order, param) {
+    validObjects([order]);
+    // 处理ReceivedNormal[]类型
+    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}`
-      );
+    // 处理ReceivedBalance类型
+    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`);
+            }
+            // 这里假设item.id是CoinWrapper类型的对象
+            tx.moveCall({
+                target: orderFn("owner_receive"),
+                arguments: [
+                    toTxObject(tx, order),
+                    toTxObject(tx, r),
+                    toTxObject(tx, p),
+                ],
+                typeArguments: [t],
+            });
+        }
     }
-    const t = match[1];
-    if (!IsValidArgType(t)) {
-      W_ERROR(WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+}
+export async function order_required_info_update(tx, order, im_or_proof) {
+    validObjects([order]);
+    if (im_or_proof !== undefined) {
+        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`);
+        }
     }
-    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"),
+    tx.moveCall({
+        target: orderFn("required_info_update"),
         arguments: [
-          toTxObject(tx, order),
-          toTxObject(tx, r),
-          toTxObject(tx, p)
+            toTxObject(tx, order),
+            tx.pure.option("address", im_or_proof),
         ],
-        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`
-      );
+export function compensation_claim(tx, param) {
+    if (!IsValidArgType(param.service_type)) {
+        W_ERROR(WErrors.InvalidParam, `Compensation claim service type ${param.service_type} is not valid`);
     }
-  }
-  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]
-  });
+    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
-};
+//# sourceMappingURL=order.js.map