wowok 2.1.10 → 2.1.13

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

@@ -1,22 +1,6 @@
-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";
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+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";
@@ -26,1467 +10,1136 @@ 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 { 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`
-          );
+export class CallMachine extends CallBase {
+    data;
+    object_address = undefined;
+    permission_address = undefined;
+    new_permission_description = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    async prepare(env) {
+        await super.prepare(env);
+        if (!this.object_address) {
+            this.object_address = await GetObjectExisted(this.data?.object);
         }
-      }
-      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.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");
             }
-            if (this.data.progress_new.repository.op === "set") {
-              context_repository_clear(
-                tx,
-                progress,
-                object,
-                permission
-              );
+        }
+        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); // prepare first.
+        const perms = [];
+        const guards = [];
+        const add_perm = (index) => {
+            if (this.permission_address && !perms.includes(index)) {
+                perms.push(index);
             }
-            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 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);
             }
-            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;
-          }
+        if (this.permission_address &&
+            this.data?.description != null &&
+            this.object_address) {
+            add_perm(BuiltinPermissionIndex.MACHINE_DESCRIPTION);
         }
-      }
-      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;
+        if (this.permission_address && this.data.repository) {
+            add_perm(BuiltinPermissionIndex.MACHINE_CONSENSUS_REPOSITORIES);
         }
-        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;
+        if (this.permission_address && this.data.node) {
+            add_perm(BuiltinPermissionIndex.MACHINE_NODE);
         }
-        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;
+        if (this.permission_address && this.data?.pause !== undefined) {
+            add_perm(BuiltinPermissionIndex.MACHINE_PAUSE);
         }
-        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;
+        if (this.permission_address && this.data?.publish !== undefined) {
+            add_perm(BuiltinPermissionIndex.MACHINE_PUBLISH);
         }
-        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;
+        if (this.permission_address && this.data?.owner_receive) {
+            add_perm(BuiltinPermissionIndex.MACHINE_OWNER_RECEIVE);
         }
-        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;
+        if (this.permission_address && this.data.um !== undefined) {
+            add_perm(BuiltinPermissionIndex.MACHINE_UM);
         }
-        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.permission_address || guards.length > 0) {
+            return await this.check_permission_and_call(env, this.permission_address, perms, guards);
         }
-      }
-    }
-    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
-          );
+        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);
         }
-      }
-      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)
-      );
-    }
-  }
+        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 (f) => await forward(tx, f)));
+                        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) {
+            // owner_receive 中完成地址查询
+            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, undefined, (name) => `${PackageAddress}::machine::${name}`, passport);
+        }
+        // 处理 um
+        if (this.data.um !== undefined) {
+            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 "";
+// ================================================
+// 常量定义
+export const MAX_CONSENSUS_REPOSITORIES_COUNT = 200;
+export const MAX_FORWARD_ORDER_COUNT = 20;
+export const MAX_NODE_PAIR_COUNT = 40;
+export const MAX_NODE_COUNT = 200;
+export const THRESHOLD_DEFAULT = 0;
+export 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`
-      );
+export 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 !== undefined &&
+        !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 === undefined) &&
+        (param.permissionIndex === null || param.permissionIndex === undefined)) {
+        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),
+            ],
+        });
     }
-    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)
-      ]
-    });
-  }
+export 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 {
+export 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)],
+        });
+    }
+}
+export function create(tx, machine) {
     return tx.moveCall({
-      target: machineFn("node2"),
-      arguments: [toTxString(tx, param.name)]
+        target: machineFn("create"),
+        arguments: [toTxObject(tx, machine)],
     });
-  }
 }
-function create(tx, machine) {
-  return tx.moveCall({
-    target: machineFn("create"),
-    arguments: [toTxObject(tx, machine)]
-  });
+// ================================================
+// 构造函数和设置函数
+export 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 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()
-      ]
-    });
-  }
+export 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 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)
-      ]
-    });
-  }
+export function node_add(tx, machine, permission, node, bCompleteReplace, passport) {
+    if (node.length === 0) {
+        return;
+    }
+    validObjects([machine, permission]);
+    if (passport) {
+        if (node.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: node,
+                    }),
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: machineFn("node_add_with_passport"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    node[0],
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+    }
+    else {
+        if (node.length > 1) {
+            tx.moveCall({
+                target: machineFn("node_add2"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    tx.makeMoveVec({
+                        type: `${PackageAddress}::machine::Node`,
+                        elements: node,
+                    }),
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: machineFn("node_add"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    node[0],
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+    }
 }
-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)
-        ]
-      });
-    }
-  }
+export 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 um_set(tx, machine, permission, um, passport) {
-  validObjects([machine, permission]);
-  if (um) {
+export function node_remove(tx, machine, permission, node, passport) {
+    if (node.length === 0) {
+        return;
+    }
+    validObjects([machine, permission]);
     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 (node.length > 1) {
+            tx.moveCall({
+                target: machineFn("node_remove_with_passport"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    tx.pure.vector("string", node),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: machineFn("node_remove_with_passport"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    tx.pure.string(node[0]),
+                ],
+            });
+        }
+    }
+    else {
+        if (node.length > 1) {
+            tx.moveCall({
+                target: machineFn("node_remove"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    tx.pure.vector("string", node),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: machineFn("node_remove"),
+                arguments: [
+                    toTxObject(tx, machine),
+                    toTxObject(tx, permission),
+                    tx.pure.string(node[0]),
+                ],
+            });
+        }
+    }
+}
+export 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(`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()
-        ]
-      });
+        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_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])
-        ]
-      });
+export 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_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)
-      ]
-    });
-  }
+export 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 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)
-      ]
-    });
-  }
+export 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 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)]
-    });
-  }
+export 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 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)]
-    });
-  }
+export 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 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)
-      ]
-    });
-  }
+export 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_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()
-      ]
-    });
-  }
+export 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(),
+            ],
+        });
+    }
 }
-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()
-      ]
-    });
-  }
+export 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 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()
-      ]
-    });
-  }
+export 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),
+            ],
+        });
+    }
 }
-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)
-      ]
-    });
-  }
+export 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),
+            ],
+        });
+    }
 }
-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)
-      ]
+export const machineNode2file = async (machine, file_path, format = "json", network) => {
+    // Get machine address
+    const machineAddr = await LocalMark.Instance().get_address(machine);
+    if (!machineAddr) {
+        throw new Error(`Machine object ${machine} not found`);
+    }
+    // Query Machine object using query_objects to verify it exists and get basic info
+    const machineQueryResult = await query_objects({
+        objects: [machineAddr],
+        network: network,
     });
-  }
-}
-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)
-      ]
+    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}`);
+    }
+    // Query all table items (nodes) from the machine
+    const tableQuery = {
+        parent: machineAddr,
+        network: network,
+    };
+    const tableResult = await query_table(tableQuery);
+    if (!tableResult?.items || tableResult.items.length === 0) {
+        throw new Error(`No nodes found in machine ${machine}`);
+    }
+    // Get all node object IDs from table result
+    const nodeObjectIds = tableResult.items.map((item) => item.object);
+    // Fetch all node details using query_objects
+    const nodeQueryResult = await query_objects({
+        objects: nodeObjectIds,
+        network: network,
     });
-  } 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)
-      ]
+    if (!nodeQueryResult?.objects || nodeQueryResult.objects.length === 0) {
+        throw new Error(`Failed to fetch any nodes from machine ${machine}`);
+    }
+    // Convert query result to MachineNode array
+    const nodes = nodeQueryResult.objects
+        .filter((obj) => obj.type === "TableItem_MachineNode")
+        .map((obj) => {
+        const nodeObj = obj;
+        return {
+            name: nodeObj.name,
+            pairs: nodeObj.value,
+        };
     });
-  }
-}
-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");
+    if (nodes.length === 0) {
+        throw new Error(`Failed to fetch any nodes from machine ${machine}`);
+    }
+    // Generate output content
+    let content;
+    if (format === "json") {
+        content = JSON.stringify(nodes, null, 2);
+    }
+    else {
+        // Markdown format
+        const machineId = machineObj.object;
+        content = generateMachineNodeMarkdown(nodes, machine, machineAddr, machineId);
+    }
+    // Write to file
+    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} |
-`;
+    let md = `# Machine Node Definition\n\n`;
+    md += `**Machine:** ${machineName}\n\n`;
+    md += `**Address:** ${machineAddr}\n\n`;
+    if (machineId) {
+        md += `**ID:** ${machineId}\n\n`;
+    }
+    md += `**Total Nodes:** ${nodes.length}\n\n`;
+    md += `---\n\n`;
+    for (const node of nodes) {
+        md += `## Node: ${node.name}\n\n`;
+        for (const pair of node.pairs) {
+            md += `### Pair: ${pair.prev_node}\n\n`;
+            md += `- **prev_node**: ${pair.prev_node}\n`;
+            md += `- **threshold**: ${pair.threshold}\n\n`;
+            if (pair.forwards && pair.forwards.length > 0) {
+                md += `#### Forwards\n\n`;
+                md += `| name | weight | namedOperator | permissionIndex | guard |\n`;
+                md += `|------|--------|---------------|-----------------|-------|\n`;
+                for (const forward of pair.forwards) {
+                    const namedOp = forward.namedOperator || "";
+                    const permIdx = forward.permissionIndex?.toString() || "";
+                    const guard = forward.guard?.guard || "";
+                    md += `| ${forward.name} | ${forward.weight} | ${namedOp} | ${permIdx} | ${guard} |\n`;
+                }
+                md += `\n`;
+            }
         }
-        md += `
-`;
-      }
-    }
-    md += `---
-
-`;
-  }
-  md += `## JSON Definition
-
-`;
-  md += `\`\`\`json
-`;
-  md += JSON.stringify(nodes, null, 2);
-  md += `
-\`\`\`
-`;
-  return md;
+        md += `---\n\n`;
+    }
+    // Add JSON code block at the end
+    md += `## JSON Definition\n\n`;
+    md += `\`\`\`json\n`;
+    md += JSON.stringify(nodes, null, 2);
+    md += `\n\`\`\`\n`;
+    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 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
-};
+//# sourceMappingURL=machine.js.map