wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1492 @@
+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,
+  toTxString,
+  isValidName,
+  isValidDescription,
+  PackageAddress,
+  MAX_NAME_LENGTH,
+  isValidU16,
+  isValidArray,
+  isValidU8,
+  isValidU32,
+  GetObjectExisted,
+  GetObject,
+  GetObjectDescription,
+  machineFn
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { ObjectType, query_table, query_objects } from "../query/object.js";
+import { writeFileSync } from "fs";
+import { CallBase } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { create as permission_create } from "./permission.js";
+import { owner_receive, validObjects } from "../util.js";
+import { LocalMark } from "../local/local.js";
+import { GetManyAccountOrMark_Address } from "../local/index.js";
+import {
+  context_repository_add,
+  context_repository_clear,
+  context_repository_remove,
+  MAX_CONTEXT_REPOSITORY_COUNT,
+  namedOperator_add,
+  namedOperator_remove,
+  namedOperator_set,
+  newProgress,
+  create as createProgress
+} from "./progress.js";
+import { query_received } from "../query/received.js";
+class CallMachine extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "permission_address");
+    __publicField(this, "new_permission_description");
+    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.Machine,
+        this.object_address
+      );
+      if (!this.content)
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallMachine_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      if (!this.permission_address) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallMachine_Data.data.object.permission is empty"
+        );
+      }
+    } else {
+      const n = GetObject(this.data.object);
+      this.permission_address = await GetObjectExisted(n?.permission);
+      this.new_permission_description = GetObjectDescription(
+        n?.permission
+      );
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const perms = [];
+    const guards = [];
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    const content = this.content;
+    if (this.permission_address && !this.object_address) {
+      add_perm(BuiltinPermissionIndex.MACHINE_NEW);
+    }
+    if (this.data?.progress_new != null) {
+      if (!content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallMachine_Data.data.progress_new fail because the Machine ${JSON.stringify(this.data.object)} content not ready`
+        );
+      }
+      add_perm(BuiltinPermissionIndex.PROGRESS_NEW);
+      if (this.data.progress_new.repository != null) {
+        add_perm(BuiltinPermissionIndex.PROGRESS_CONTEXT_REPOSITORY);
+      }
+      if (this.data.progress_new.progress_namedOperator != null) {
+        add_perm(BuiltinPermissionIndex.PROGRESS_NAMED_OPERATOR);
+      }
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(BuiltinPermissionIndex.MACHINE_DESCRIPTION);
+    }
+    if (this.permission_address && this.data.repository) {
+      add_perm(BuiltinPermissionIndex.MACHINE_CONSENSUS_REPOSITORIES);
+    }
+    if (this.permission_address && this.data.node) {
+      add_perm(BuiltinPermissionIndex.MACHINE_NODE);
+    }
+    if (this.permission_address && this.data?.pause !== void 0) {
+      add_perm(BuiltinPermissionIndex.MACHINE_PAUSE);
+    }
+    if (this.permission_address && this.data?.publish !== void 0) {
+      add_perm(BuiltinPermissionIndex.MACHINE_PUBLISH);
+    }
+    if (this.permission_address && this.data?.owner_receive) {
+      add_perm(BuiltinPermissionIndex.MACHINE_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data.um !== void 0) {
+      add_perm(BuiltinPermissionIndex.MACHINE_UM);
+    }
+    if (this.permission_address || guards.length > 0) {
+      return await this.check_permission_and_call(
+        env,
+        this.permission_address,
+        perms,
+        guards
+      );
+    }
+    return await this.exec(env);
+  }
+  async operate(env, tx, passport, submission) {
+    let permission = this.permission_address;
+    let object = this.object_address;
+    const content = this.content;
+    if (!this.object_address) {
+      if (!permission) {
+        permission = newPermission(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission) {
+        object = newMachine(
+          tx,
+          toTxObject(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        "CallMachine_Data.data.object:" + this.object_address
+      );
+    }
+    if (this.data.progress_new != null) {
+      if (!content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallMachine_Data.data.progress_new fail because the Machine ${JSON.stringify(this.data.object)} content not ready`
+        );
+      }
+      if (this.data.progress_new.task != null) {
+        const t = await GetObjectExisted(this.data.progress_new.task);
+        if (t) {
+          this.data.progress_new.task = t;
+        } else {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `CallMachine_Data.data.progress_new.task: ${this.data.progress_new.task} not found`
+          );
+        }
+      }
+      const progress = newProgress(
+        tx,
+        object,
+        permission,
+        this.data.progress_new.task ?? null,
+        passport
+      );
+      if (this.data.progress_new.repository != null) {
+        switch (this.data.progress_new.repository.op) {
+          case "add":
+          case "set": {
+            if (this.data.progress_new.repository.objects.length > MAX_CONTEXT_REPOSITORY_COUNT) {
+              W_ERROR(
+                WErrors.InvalidParam,
+                `CallProgress_Data.data.progress_new.repository.objects exceeds max count:${this.data.progress_new.repository.objects}`
+              );
+            }
+            if (this.data.progress_new.repository.op === "set") {
+              context_repository_clear(
+                tx,
+                progress,
+                object,
+                permission
+              );
+            }
+            const r = await LocalMark.Instance().get_many_address_availables(
+              this.data.progress_new.repository.objects
+            );
+            r.forEach((repo) => {
+              context_repository_add(
+                tx,
+                progress,
+                object,
+                permission,
+                repo,
+                passport
+              );
+            });
+            break;
+          }
+          case "remove": {
+            if (this.data.progress_new.repository.objects.length > MAX_CONTEXT_REPOSITORY_COUNT) {
+              W_ERROR(
+                WErrors.InvalidParam,
+                `CallProgress_Data.data.progress_new.repository.objects exceeds max count:${this.data.progress_new.repository.objects}`
+              );
+            }
+            const addrs = await LocalMark.Instance().get_many_address_availables(
+              this.data.progress_new.repository.objects
+            );
+            context_repository_remove(
+              tx,
+              progress,
+              object,
+              permission,
+              addrs,
+              passport
+            );
+            break;
+          }
+          case "clear":
+            context_repository_clear(
+              tx,
+              progress,
+              object,
+              permission,
+              passport
+            );
+            break;
+        }
+      }
+      if (this.data.progress_new.progress_namedOperator != null) {
+        switch (this.data.progress_new.progress_namedOperator.op) {
+          case "add": {
+            const r = await GetManyAccountOrMark_Address(
+              this.data.progress_new.progress_namedOperator.operators
+            );
+            namedOperator_add(
+              tx,
+              progress,
+              object,
+              permission,
+              this.data.progress_new.progress_namedOperator.name,
+              r,
+              passport
+            );
+            break;
+          }
+          case "set": {
+            const r = await GetManyAccountOrMark_Address(
+              this.data.progress_new.progress_namedOperator.operators
+            );
+            namedOperator_set(
+              tx,
+              progress,
+              object,
+              permission,
+              this.data.progress_new.progress_namedOperator.name,
+              r,
+              passport
+            );
+            break;
+          }
+          case "remove": {
+            const r = await GetManyAccountOrMark_Address(
+              this.data.progress_new.progress_namedOperator.operators
+            );
+            namedOperator_remove(
+              tx,
+              progress,
+              object,
+              permission,
+              this.data.progress_new.progress_namedOperator.name,
+              r,
+              passport
+            );
+            break;
+          }
+        }
+      }
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Progress,
+        createProgress(tx, progress),
+        GetObject(this.data.progress_new.namedNew)
+      );
+    }
+    if (this.data?.description != null && this.object_address) {
+      description_set(
+        tx,
+        object,
+        permission,
+        this.data.description,
+        passport
+      );
+    }
+    if (this.data.repository) {
+      switch (this.data.repository.op) {
+        case "add":
+        case "set": {
+          if (this.data.repository.objects.length > MAX_CONSENSUS_REPOSITORIES_COUNT - (content?.consensus_repositories?.length ?? 0)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `CallService_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
+            );
+          }
+          if (this.data.repository.op === "set") {
+            consensus_repositories_clear(
+              tx,
+              object,
+              permission,
+              passport
+            );
+          }
+          const r = await LocalMark.Instance().get_many_address_availables(
+            this.data.repository.objects
+          );
+          r.forEach((repo) => {
+            consensus_repositories_add(
+              tx,
+              object,
+              permission,
+              repo,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.repository.objects.length > (content?.consensus_repositories?.length ?? 0)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `CallService_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
+            );
+          }
+          const addrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.repository.objects
+          );
+          consensus_repositories_remove(
+            tx,
+            object,
+            permission,
+            addrs,
+            passport
+          );
+          break;
+        }
+        case "clear":
+          consensus_repositories_clear(
+            tx,
+            object,
+            permission,
+            passport
+          );
+          break;
+      }
+    }
+    if (this.data.node) {
+      switch (this.data.node.op) {
+        case "add":
+        case "set": {
+          if (this.data.node.nodes.length > MAX_NODE_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `CallMachine_Data.data.node.nodes exceeds max count:${this.data.node.nodes}`
+            );
+          }
+          if (this.data.node.op === "set") {
+            node_clear(tx, object, permission, passport);
+          }
+          const nodes = await Promise.all(
+            this.data.node.nodes.map(
+              async (n) => await node(tx, n)
+            )
+          );
+          node_add(
+            tx,
+            object,
+            permission,
+            nodes,
+            this.data.node.bReplace ?? false,
+            passport
+          );
+          break;
+        }
+        case "remove": {
+          if (this.data.node.nodes.length > (content?.node_count ?? 0)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `CallMachine_Data.data.node.nodes exceeds max count:${this.data.node.nodes}`
+            );
+          }
+          node_remove(
+            tx,
+            object,
+            permission,
+            this.data.node.nodes,
+            passport
+          );
+          break;
+        }
+        case "clear":
+          node_clear(tx, object, permission, passport);
+          break;
+        case "exchange":
+          node_exchange_name(
+            tx,
+            object,
+            permission,
+            this.data.node.node_one,
+            this.data.node.node_other,
+            passport
+          );
+          break;
+        case "rename":
+          node_rename(
+            tx,
+            object,
+            permission,
+            this.data.node.node_name_old,
+            this.data.node.node_name_new,
+            passport
+          );
+          break;
+        case "add forward": {
+          for (const item of this.data.node.data) {
+            const f = await Promise.all(
+              item.forward.map(async (f2) => await forward(tx, f2))
+            );
+            await forwards_add(
+              tx,
+              object,
+              permission,
+              item.prior_node_name,
+              item.node_name,
+              f,
+              item.threshold ?? null
+            );
+          }
+          break;
+        }
+        case "remove forward": {
+          for (const item of this.data.node.data) {
+            forwards_remove(
+              tx,
+              object,
+              permission,
+              item.prior_node_name,
+              item.node_name,
+              item.forward_name,
+              null
+            );
+          }
+          break;
+        }
+        case "remove prior node": {
+          for (const item of this.data.node.pairs) {
+            prev_nodes_remove(
+              tx,
+              object,
+              permission,
+              item.node_name,
+              item.prior_node_name
+            );
+          }
+          break;
+        }
+      }
+    }
+    if (this.data.pause != null) {
+      pause(
+        tx,
+        object,
+        permission,
+        this.data.pause ? true : false,
+        passport
+      );
+    }
+    if (this.data.publish != null) {
+      publish(tx, object, permission, passport);
+    }
+    if (this.data.owner_receive != null && this.object_address) {
+      if (this.data.owner_receive === "recently") {
+        this.data.owner_receive = await query_received({
+          object: this.object_address,
+          all_type: true,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      }
+      await owner_receive(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        void 0,
+        (name) => `${PackageAddress}::machine::${name}`,
+        passport
+      );
+    }
+    if (this.data.um !== void 0) {
+      let um_address = null;
+      if (this.data.um) {
+        um_address = await LocalMark.Instance().get_address(this.data.um) || null;
+        if (!um_address) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallMachine_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(tx, object, permission, um_address, passport);
+    }
+    if (!this.permission_address) {
+      const p = GetObject(this.data?.object);
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Permission,
+        permission_create(tx, permission),
+        GetObject(p.permission)
+      );
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Machine,
+        create(tx, object),
+        GetObject(this.data?.object)
+      );
+    }
+  }
+}
+const MAX_CONSENSUS_REPOSITORIES_COUNT = 200;
+const MAX_FORWARD_ORDER_COUNT = 20;
+const MAX_NODE_PAIR_COUNT = 40;
+const MAX_NODE_COUNT = 200;
+const THRESHOLD_DEFAULT = 0;
+function init_node_name() {
+  return "";
+}
+async function forward(tx, param) {
+  if (typeof param.name === "string" && !isValidName(param.name)) {
+    W_ERROR(
+      WErrors.IsValidName,
+      `Forward name ${param.name} exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (typeof param.namedOperator === "string" && !isValidName(param.namedOperator)) {
+    W_ERROR(
+      WErrors.IsValidName,
+      `Named operator ${param.namedOperator} exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (param.permissionIndex !== void 0 && !isValidU16(param.permissionIndex)) {
+    W_ERROR(
+      WErrors.IsValidArgType,
+      `Permission index must be between 0 and 65535`
+    );
+  }
+  if (!isValidU16(param.weight)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Weight ${param.weight} must be between 0 and 65535`
+    );
+  }
+  if ((param.namedOperator === null || param.namedOperator === void 0) && (param.permissionIndex === null || param.permissionIndex === void 0)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `One of the "namedOperator" or "permissionIndex" must be provided`
+    );
+  }
+  if (param.guard && param.guard.guard != null) {
+    const guard = await LocalMark.Instance().get_address(param.guard.guard);
+    if (guard) {
+      param.guard.guard = guard;
+    } else {
+      W_ERROR(
+        WErrors.IsValidName,
+        `Guard object ${param.guard.guard} is not a valid wow address`
+      );
+    }
+    if (param.guard.retained_submission != null && !isValidArray(param.guard.retained_submission, isValidU8)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Retained submission ${param.guard.retained_submission} must be between 0 and 255`
+      );
+    }
+    return tx.moveCall({
+      target: machineFn("forward_with_guard"),
+      arguments: [
+        toTxString(tx, param.name),
+        tx.pure.option("string", param.namedOperator ?? null),
+        tx.pure.option("u16", param.permissionIndex ?? null),
+        tx.pure.u16(param.weight),
+        toTxObject(tx, param.guard.guard),
+        tx.pure.vector("u8", param.guard.retained_submission ?? [])
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: machineFn("forward"),
+      arguments: [
+        toTxString(tx, param.name),
+        tx.pure.option("string", param.namedOperator ?? null),
+        tx.pure.option("u16", param.permissionIndex ?? null),
+        tx.pure.u16(param.weight)
+      ]
+    });
+  }
+}
+async function nodepair(tx, prev_node, param) {
+  if (typeof prev_node === "string" && prev_node.length > 0 && !isValidName(prev_node)) {
+    W_ERROR(
+      WErrors.IsValidName,
+      `Previous node name ${prev_node} exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (typeof param.threshold === "number" && !isValidU32(param.threshold)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Threshold ${param.threshold} must be between 0 and 4294967295`
+    );
+  }
+  if (param.forwards.length > MAX_FORWARD_ORDER_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Forward order count ${param.forwards.length} exceeds maximum count ${MAX_FORWARD_ORDER_COUNT}`
+    );
+  }
+  if (param.forwards.length > 1) {
+    const forwards = await Promise.all(
+      param.forwards.map((f) => forward(tx, f))
+    );
+    return tx.moveCall({
+      target: machineFn("nodepair3"),
+      arguments: [
+        toTxString(tx, prev_node),
+        tx.pure.option("u32", param.threshold ?? null),
+        tx.makeMoveVec({
+          type: `${PackageAddress}::machine::Forward`,
+          elements: forwards
+        })
+      ]
+    });
+  } else if (param.forwards.length === 1) {
+    return tx.moveCall({
+      target: machineFn("nodepair"),
+      arguments: [
+        toTxString(tx, prev_node),
+        tx.pure.option("u32", param.threshold ?? null),
+        await forward(tx, param.forwards[0])
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: machineFn("nodepair2"),
+      arguments: [
+        toTxString(tx, prev_node),
+        tx.pure.option("u32", param.threshold ?? null)
+      ]
+    });
+  }
+}
+async function node(tx, param) {
+  if (typeof param.name === "string" && !isValidName(param.name)) {
+    W_ERROR(
+      WErrors.IsValidName,
+      `Node name ${param.name} exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (param.name === init_node_name()) {
+    W_ERROR(WErrors.InvalidParam, `Node name ${param.name} is reserved`);
+  }
+  if (param.pairs.length > MAX_NODE_PAIR_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Node pair count ${param.pairs.length} exceeds maximum count ${MAX_NODE_PAIR_COUNT}`
+    );
+  }
+  if (param.pairs.length > 1) {
+    const pairs = await Promise.all(
+      param.pairs.map((p) => nodepair(tx, p.prev_node, p))
+    );
+    return tx.moveCall({
+      target: machineFn("node3"),
+      arguments: [
+        toTxString(tx, param.name),
+        tx.makeMoveVec({
+          type: `${PackageAddress}::machine::NodePair`,
+          elements: pairs
+        })
+      ]
+    });
+  } else if (param.pairs.length === 1) {
+    return tx.moveCall({
+      target: machineFn("node"),
+      arguments: [
+        toTxString(tx, param.name),
+        await nodepair(tx, param.pairs[0].prev_node, param.pairs[0])
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: machineFn("node2"),
+      arguments: [toTxString(tx, param.name)]
+    });
+  }
+}
+function create(tx, machine) {
+  return tx.moveCall({
+    target: machineFn("create"),
+    arguments: [toTxObject(tx, machine)]
+  });
+}
+function newMachine(tx, permission, description, passport) {
+  validObjects([permission]);
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: machineFn("new_with_passport"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: machineFn("new"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function description_set(tx, machine, permission, description, passport) {
+  validObjects([machine, permission]);
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("description_set_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("description_set"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, description)
+      ]
+    });
+  }
+}
+function node_add(tx, machine, permission, node2, bCompleteReplace, passport) {
+  if (node2.length === 0) {
+    return;
+  }
+  validObjects([machine, permission]);
+  if (passport) {
+    if (node2.length > 1) {
+      tx.moveCall({
+        target: machineFn("node_add2_with_passport"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          tx.makeMoveVec({
+            type: `${PackageAddress}::machine::Node`,
+            elements: node2
+          }),
+          tx.pure.bool(bCompleteReplace)
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: machineFn("node_add_with_passport"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          node2[0],
+          tx.pure.bool(bCompleteReplace)
+        ]
+      });
+    }
+  } else {
+    if (node2.length > 1) {
+      tx.moveCall({
+        target: machineFn("node_add2"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          tx.makeMoveVec({
+            type: `${PackageAddress}::machine::Node`,
+            elements: node2
+          }),
+          tx.pure.bool(bCompleteReplace)
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: machineFn("node_add"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          node2[0],
+          tx.pure.bool(bCompleteReplace)
+        ]
+      });
+    }
+  }
+}
+function um_set(tx, machine, permission, um, passport) {
+  validObjects([machine, permission]);
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: machineFn(`um_set_with_passport`),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          passport,
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: machineFn(`um_set`),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: machineFn(`um_none_with_passport`),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: machineFn(`um_none`),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          tx.object.mutRegistrar()
+        ]
+      });
+    }
+  }
+}
+function node_remove(tx, machine, permission, node2, passport) {
+  if (node2.length === 0) {
+    return;
+  }
+  validObjects([machine, permission]);
+  if (passport) {
+    if (node2.length > 1) {
+      tx.moveCall({
+        target: machineFn("node_remove_with_passport"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          tx.pure.vector("string", node2)
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: machineFn("node_remove_with_passport"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          toTxObject(tx, passport),
+          tx.pure.string(node2[0])
+        ]
+      });
+    }
+  } else {
+    if (node2.length > 1) {
+      tx.moveCall({
+        target: machineFn("node_remove"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          tx.pure.vector("string", node2)
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: machineFn("node_remove"),
+        arguments: [
+          toTxObject(tx, machine),
+          toTxObject(tx, permission),
+          tx.pure.string(node2[0])
+        ]
+      });
+    }
+  }
+}
+function node_rename(tx, machine, permission, node_name, node_new_name, passport) {
+  if (!node_name || !node_new_name) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Node name ${node_name} or new node name ${node_new_name} is empty`
+    );
+  }
+  validObjects([machine, permission]);
+  if (!isValidName(node_name)) {
+    W_ERROR(WErrors.InvalidParam, `Node name ${node_name} is invalid`);
+  }
+  if (!isValidName(node_new_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `New node name ${node_new_name} is invalid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("node_rename_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.string(node_name),
+        tx.pure.string(node_new_name)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("node_rename"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.string(node_name),
+        tx.pure.string(node_new_name)
+      ]
+    });
+  }
+}
+function node_exchange_name(tx, machine, permission, node_one, node_other, passport) {
+  validObjects([machine, permission]);
+  if (!node_one || !node_other) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Node one ${node_one} or node other ${node_other} is empty`
+    );
+  }
+  if (!isValidName(node_one)) {
+    W_ERROR(WErrors.InvalidParam, `Node one ${node_one} is invalid`);
+  }
+  if (!isValidName(node_other)) {
+    W_ERROR(WErrors.InvalidParam, `Node other ${node_other} is invalid`);
+  }
+  if (node_one === node_other) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Node one ${node_one} and node other ${node_other} are same`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("node_exchange_name_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.string(node_one),
+        tx.pure.string(node_other)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("node_exchange_name"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.string(node_one),
+        tx.pure.string(node_other)
+      ]
+    });
+  }
+}
+function node_clear(tx, machine, permission, passport) {
+  validObjects([machine, permission]);
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("node_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("node_clear"),
+      arguments: [toTxObject(tx, machine), toTxObject(tx, permission)]
+    });
+  }
+}
+function publish(tx, machine, permission, passport) {
+  validObjects([machine, permission]);
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("publish_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("publish"),
+      arguments: [toTxObject(tx, machine), toTxObject(tx, permission)]
+    });
+  }
+}
+function pause(tx, machine, permission, bPaused, passport) {
+  validObjects([machine, permission]);
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("pause_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.bool(bPaused)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("pause"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.bool(bPaused)
+      ]
+    });
+  }
+}
+function consensus_repositories_add(tx, machine, permission, repository, passport) {
+  validObjects([machine, permission, repository]);
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("consensus_repositories_add_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("consensus_repositories_add"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, repository),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function consensus_repositories_remove(tx, machine, permission, repositories, passport) {
+  if (!repositories || repositories.length === 0) {
+    return;
+  }
+  validObjects([machine, permission, ...repositories]);
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("consensus_repositories_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("string", repositories),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("consensus_repositories_remove"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.pure.vector("string", repositories),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function consensus_repositories_clear(tx, machine, permission, passport) {
+  validObjects([machine, permission]);
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("consensus_repositories_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("consensus_repositories_clear"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+async function forwards_add(tx, machine, permission, node_name, next_node_name, forwards, threshold, passport) {
+  if (!forwards || forwards.length === 0) {
+    return;
+  }
+  validObjects([machine, permission]);
+  if (threshold !== null && !isValidU32(threshold)) {
+    W_ERROR(WErrors.InvalidParam, `threshold ${threshold} must be u32`);
+  }
+  if (!isValidName(node_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `node_name ${node_name} is excceed max length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (!isValidName(next_node_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `next_node_name ${next_node_name} is excceed max length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("forwards_add_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, node_name),
+        toTxString(tx, next_node_name),
+        tx.makeMoveVec({
+          type: `${PackageAddress}::machine::Forward`,
+          elements: forwards
+        }),
+        tx.pure.option("u32", threshold ?? null)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("forwards_add"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, node_name),
+        toTxString(tx, next_node_name),
+        tx.makeMoveVec({
+          type: `${PackageAddress}::machine::Forward`,
+          elements: forwards
+        }),
+        tx.pure.option("u32", threshold ?? null)
+      ]
+    });
+  }
+}
+function forwards_remove(tx, machine, permission, node_name, next_node_name, forwards, threshold, passport) {
+  if (!forwards || forwards.length === 0) {
+    return;
+  }
+  validObjects([machine, permission, ...forwards]);
+  if (!isValidName(node_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `node_name ${node_name} is excceed max length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (!isValidName(next_node_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `next_node_name ${next_node_name} is excceed max length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (threshold !== null && !isValidU32(threshold)) {
+    W_ERROR(WErrors.InvalidParam, `threshold ${threshold} must be u32`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("forwards_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, node_name),
+        toTxString(tx, next_node_name),
+        tx.pure.vector("string", forwards),
+        tx.pure.option("u32", threshold ?? null)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("forwards_remove"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, node_name),
+        toTxString(tx, next_node_name),
+        tx.pure.vector("string", forwards),
+        tx.pure.option("u32", threshold ?? null)
+      ]
+    });
+  }
+}
+function prev_nodes_remove(tx, machine, permission, node_name, prev_node_names, passport) {
+  if (prev_node_names.length === 0) {
+    return;
+  }
+  validObjects([machine, permission]);
+  if (!isValidName(node_name)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `node_name ${node_name} is excceed max length ${MAX_NAME_LENGTH}`
+    );
+  }
+  for (const prev_node_name of prev_node_names) {
+    if (!isValidName(prev_node_name)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `prev_node_name ${prev_node_name} is excceed max length ${MAX_NAME_LENGTH}`
+      );
+    }
+  }
+  if (passport) {
+    tx.moveCall({
+      target: machineFn("prev_nodes_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, node_name),
+        tx.pure.vector("string", prev_node_names)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: machineFn("prev_nodes_remove"),
+      arguments: [
+        toTxObject(tx, machine),
+        toTxObject(tx, permission),
+        toTxString(tx, node_name),
+        tx.pure.vector("string", prev_node_names)
+      ]
+    });
+  }
+}
+const machineNode2file = async (machine, file_path, format = "json", network) => {
+  const machineAddr = await LocalMark.Instance().get_address(machine);
+  if (!machineAddr) {
+    throw new Error(`Machine object ${machine} not found`);
+  }
+  const machineQueryResult = await query_objects({
+    objects: [machineAddr],
+    network
+  });
+  if (!machineQueryResult?.objects || machineQueryResult.objects.length === 0) {
+    throw new Error(
+      `Machine object ${machine} (${machineAddr}) not found on chain`
+    );
+  }
+  const machineObj = machineQueryResult.objects[0];
+  if (machineObj.type !== "Machine") {
+    throw new Error(
+      `Object ${machine} is not a Machine, found type: ${machineObj.type}`
+    );
+  }
+  const tableQuery = {
+    parent: machineAddr,
+    network
+  };
+  const tableResult = await query_table(tableQuery);
+  if (!tableResult?.items || tableResult.items.length === 0) {
+    throw new Error(`No nodes found in machine ${machine}`);
+  }
+  const nodeObjectIds = tableResult.items.map((item) => item.object);
+  const nodeQueryResult = await query_objects({
+    objects: nodeObjectIds,
+    network
+  });
+  if (!nodeQueryResult?.objects || nodeQueryResult.objects.length === 0) {
+    throw new Error(`Failed to fetch any nodes from machine ${machine}`);
+  }
+  const nodes = nodeQueryResult.objects.filter((obj) => obj.type === "TableItem_MachineNode").map((obj) => {
+    const nodeObj = obj;
+    return {
+      name: nodeObj.name,
+      pairs: nodeObj.value
+    };
+  });
+  if (nodes.length === 0) {
+    throw new Error(`Failed to fetch any nodes from machine ${machine}`);
+  }
+  let content;
+  if (format === "json") {
+    content = JSON.stringify(nodes, null, 2);
+  } else {
+    const machineId = machineObj.object;
+    content = generateMachineNodeMarkdown(
+      nodes,
+      machine,
+      machineAddr,
+      machineId
+    );
+  }
+  writeFileSync(file_path, content, "utf-8");
+};
+function generateMachineNodeMarkdown(nodes, machineName, machineAddr, machineId) {
+  let md = `# Machine Node Definition
+
+`;
+  md += `**Machine:** ${machineName}
+
+`;
+  md += `**Address:** ${machineAddr}
+
+`;
+  if (machineId) {
+    md += `**ID:** ${machineId}
+
+`;
+  }
+  md += `**Total Nodes:** ${nodes.length}
+
+`;
+  md += `---
+
+`;
+  for (const node2 of nodes) {
+    md += `## Node: ${node2.name}
+
+`;
+    for (const pair of node2.pairs) {
+      md += `### Pair: ${pair.prev_node}
+
+`;
+      md += `- **prev_node**: ${pair.prev_node}
+`;
+      md += `- **threshold**: ${pair.threshold}
+
+`;
+      if (pair.forwards && pair.forwards.length > 0) {
+        md += `#### Forwards
+
+`;
+        md += `| name | weight | namedOperator | permissionIndex | guard |
+`;
+        md += `|------|--------|---------------|-----------------|-------|
+`;
+        for (const forward2 of pair.forwards) {
+          const namedOp = forward2.namedOperator || "";
+          const permIdx = forward2.permissionIndex?.toString() || "";
+          const guard = forward2.guard?.guard || "";
+          md += `| ${forward2.name} | ${forward2.weight} | ${namedOp} | ${permIdx} | ${guard} |
+`;
+        }
+        md += `
+`;
+      }
+    }
+    md += `---
+
+`;
+  }
+  md += `## JSON Definition
+
+`;
+  md += `\`\`\`json
+`;
+  md += JSON.stringify(nodes, null, 2);
+  md += `
+\`\`\`
+`;
+  return md;
+}
+function prev_nodes_remove_with_passport(tx, machine, permission, passport, node_name, prev_node_names) {
+  validObjects([machine, permission, passport]);
+  tx.moveCall({
+    target: machineFn("prev_nodes_remove_with_passport"),
+    arguments: [
+      toTxObject(tx, machine),
+      toTxObject(tx, permission),
+      toTxObject(tx, passport),
+      toTxString(tx, node_name),
+      tx.pure.vector("string", prev_node_names)
+    ]
+  });
+}
+export {
+  CallMachine,
+  MAX_CONSENSUS_REPOSITORIES_COUNT,
+  MAX_FORWARD_ORDER_COUNT,
+  MAX_NODE_COUNT,
+  MAX_NODE_PAIR_COUNT,
+  THRESHOLD_DEFAULT,
+  consensus_repositories_add,
+  consensus_repositories_clear,
+  consensus_repositories_remove,
+  create,
+  description_set,
+  forward,
+  forwards_add,
+  forwards_remove,
+  init_node_name,
+  machineNode2file,
+  newMachine,
+  node,
+  node_add,
+  node_clear,
+  node_exchange_name,
+  node_remove,
+  node_rename,
+  nodepair,
+  pause,
+  prev_nodes_remove,
+  prev_nodes_remove_with_passport,
+  publish,
+  um_set
+};