wowok 2.1.10 → 2.1.13

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

@@ -1,1486 +1,1172 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var machine_exports = {};
-__export(machine_exports, {
-  CallMachine: () => CallMachine,
-  MAX_CONSENSUS_REPOSITORIES_COUNT: () => MAX_CONSENSUS_REPOSITORIES_COUNT,
-  MAX_FORWARD_ORDER_COUNT: () => MAX_FORWARD_ORDER_COUNT,
-  MAX_NODE_COUNT: () => MAX_NODE_COUNT,
-  MAX_NODE_PAIR_COUNT: () => MAX_NODE_PAIR_COUNT,
-  THRESHOLD_DEFAULT: () => THRESHOLD_DEFAULT,
-  consensus_repositories_add: () => consensus_repositories_add,
-  consensus_repositories_clear: () => consensus_repositories_clear,
-  consensus_repositories_remove: () => consensus_repositories_remove,
-  create: () => create,
-  description_set: () => description_set,
-  forward: () => forward,
-  forwards_add: () => forwards_add,
-  forwards_remove: () => forwards_remove,
-  init_node_name: () => init_node_name,
-  machineNode2file: () => machineNode2file,
-  newMachine: () => newMachine,
-  node: () => node,
-  node_add: () => node_add,
-  node_clear: () => node_clear,
-  node_exchange_name: () => node_exchange_name,
-  node_remove: () => node_remove,
-  node_rename: () => node_rename,
-  nodepair: () => nodepair,
-  pause: () => pause,
-  prev_nodes_remove: () => prev_nodes_remove,
-  prev_nodes_remove_with_passport: () => prev_nodes_remove_with_passport,
-  publish: () => publish,
-  um_set: () => um_set
-});
-module.exports = __toCommonJS(machine_exports);
-var import_common = require("../common.js");
-var import_exception = require("../exception.js");
-var import_object = require("../query/object.js");
-var import_fs = require("fs");
-var import_base = require("./base.js");
-var import_permission = require("./permission.js");
-var import_permission2 = require("./permission.js");
-var import_util = require("../util.js");
-var import_local = require("../local/local.js");
-var import_local2 = require("../local/index.js");
-var import_progress = require("./progress.js");
-var import_received = require("../query/received.js");
-class CallMachine extends import_base.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 (0, import_common.GetObjectExisted)(this.data?.object);
-    }
-    if (this.object_address) {
-      await this.update_content(
-        env,
-        import_object.ObjectType.Machine,
-        this.object_address
-      );
-      if (!this.content)
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallMachine_Data.data.object:" + this.object_address
-        );
-      this.permission_address = this.content.permission;
-      if (!this.permission_address) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallMachine_Data.data.object.permission is empty"
-        );
-      }
-    } else {
-      const n = (0, import_common.GetObject)(this.data.object);
-      this.permission_address = await (0, import_common.GetObjectExisted)(n?.permission);
-      this.new_permission_description = (0, import_common.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(import_permission.BuiltinPermissionIndex.MACHINE_NEW);
-    }
-    if (this.data?.progress_new != null) {
-      if (!content) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          `CallMachine_Data.data.progress_new fail because the Machine ${JSON.stringify(this.data.object)} content not ready`
-        );
-      }
-      add_perm(import_permission.BuiltinPermissionIndex.PROGRESS_NEW);
-      if (this.data.progress_new.repository != null) {
-        add_perm(import_permission.BuiltinPermissionIndex.PROGRESS_CONTEXT_REPOSITORY);
-      }
-      if (this.data.progress_new.progress_namedOperator != null) {
-        add_perm(import_permission.BuiltinPermissionIndex.PROGRESS_NAMED_OPERATOR);
-      }
-    }
-    if (this.permission_address && this.data?.description != null && this.object_address) {
-      add_perm(import_permission.BuiltinPermissionIndex.MACHINE_DESCRIPTION);
-    }
-    if (this.permission_address && this.data.repository) {
-      add_perm(import_permission.BuiltinPermissionIndex.MACHINE_CONSENSUS_REPOSITORIES);
-    }
-    if (this.permission_address && this.data.node) {
-      add_perm(import_permission.BuiltinPermissionIndex.MACHINE_NODE);
-    }
-    if (this.permission_address && this.data?.pause !== void 0) {
-      add_perm(import_permission.BuiltinPermissionIndex.MACHINE_PAUSE);
-    }
-    if (this.permission_address && this.data?.publish !== void 0) {
-      add_perm(import_permission.BuiltinPermissionIndex.MACHINE_PUBLISH);
-    }
-    if (this.permission_address && this.data?.owner_receive) {
-      add_perm(import_permission.BuiltinPermissionIndex.MACHINE_OWNER_RECEIVE);
-    }
-    if (this.permission_address && this.data.um !== void 0) {
-      add_perm(import_permission.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 = (0, import_permission.newPermission)(
-          tx,
-          this.new_permission_description ?? ""
-        );
-      }
-      if (permission) {
-        object = newMachine(
-          tx,
-          (0, import_common.toTxObject)(tx, permission),
-          this.data?.description ?? "",
-          passport
-        );
-      }
-    }
-    if (!object || !permission) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        "CallMachine_Data.data.object:" + this.object_address
-      );
-    }
-    if (this.data.progress_new != null) {
-      if (!content) {
-        (0, import_exception.W_ERROR)(
-          import_exception.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 (0, import_common.GetObjectExisted)(this.data.progress_new.task);
-        if (t) {
-          this.data.progress_new.task = t;
-        } else {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `CallMachine_Data.data.progress_new.task: ${this.data.progress_new.task} not found`
-          );
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.machineNode2file = exports.THRESHOLD_DEFAULT = exports.MAX_NODE_COUNT = exports.MAX_NODE_PAIR_COUNT = exports.MAX_FORWARD_ORDER_COUNT = exports.MAX_CONSENSUS_REPOSITORIES_COUNT = exports.CallMachine = void 0;
+exports.init_node_name = init_node_name;
+exports.forward = forward;
+exports.nodepair = nodepair;
+exports.node = node;
+exports.create = create;
+exports.newMachine = newMachine;
+exports.description_set = description_set;
+exports.node_add = node_add;
+exports.um_set = um_set;
+exports.node_remove = node_remove;
+exports.node_rename = node_rename;
+exports.node_exchange_name = node_exchange_name;
+exports.node_clear = node_clear;
+exports.publish = publish;
+exports.pause = pause;
+exports.consensus_repositories_add = consensus_repositories_add;
+exports.consensus_repositories_remove = consensus_repositories_remove;
+exports.consensus_repositories_clear = consensus_repositories_clear;
+exports.forwards_add = forwards_add;
+exports.forwards_remove = forwards_remove;
+exports.prev_nodes_remove = prev_nodes_remove;
+exports.prev_nodes_remove_with_passport = prev_nodes_remove_with_passport;
+const common_js_1 = require("../common.js");
+const exception_js_1 = require("../exception.js");
+const object_js_1 = require("../query/object.js");
+const fs_1 = require("fs");
+const base_js_1 = require("./base.js");
+const permission_js_1 = require("./permission.js");
+const permission_js_2 = require("./permission.js");
+const util_js_1 = require("../util.js");
+const local_js_1 = require("../local/local.js");
+const index_js_1 = require("../local/index.js");
+const progress_js_1 = require("./progress.js");
+const received_js_1 = require("../query/received.js");
+class CallMachine extends base_js_1.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 (0, common_js_1.GetObjectExisted)(this.data?.object);
         }
-      }
-      const progress = (0, import_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 > import_progress.MAX_CONTEXT_REPOSITORY_COUNT) {
-              (0, import_exception.W_ERROR)(
-                import_exception.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, object_js_1.ObjectType.Machine, this.object_address);
+            if (!this.content)
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallMachine_Data.data.object:" + this.object_address);
+            this.permission_address = this.content.permission;
+            if (!this.permission_address) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallMachine_Data.data.object.permission is empty");
             }
-            if (this.data.progress_new.repository.op === "set") {
-              (0, import_progress.context_repository_clear)(
-                tx,
-                progress,
-                object,
-                permission
-              );
+        }
+        else {
+            const n = (0, common_js_1.GetObject)(this.data.object);
+            this.permission_address = await (0, common_js_1.GetObjectExisted)(n?.permission);
+            this.new_permission_description = (0, common_js_1.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 import_local.LocalMark.Instance().get_many_address_availables(
-              this.data.progress_new.repository.objects
-            );
-            r.forEach((repo) => {
-              (0, import_progress.context_repository_add)(
-                tx,
-                progress,
-                object,
-                permission,
-                repo,
-                passport
-              );
-            });
-            break;
-          }
-          case "remove": {
-            if (this.data.progress_new.repository.objects.length > import_progress.MAX_CONTEXT_REPOSITORY_COUNT) {
-              (0, import_exception.W_ERROR)(
-                import_exception.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(permission_js_1.BuiltinPermissionIndex.MACHINE_NEW);
+        }
+        if (this.data?.progress_new != null) {
+            if (!content) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallMachine_Data.data.progress_new fail because the Machine ${JSON.stringify(this.data.object)} content not ready`);
+            }
+            add_perm(permission_js_1.BuiltinPermissionIndex.PROGRESS_NEW);
+            if (this.data.progress_new.repository != null) {
+                add_perm(permission_js_1.BuiltinPermissionIndex.PROGRESS_CONTEXT_REPOSITORY);
+            }
+            if (this.data.progress_new.progress_namedOperator != null) {
+                add_perm(permission_js_1.BuiltinPermissionIndex.PROGRESS_NAMED_OPERATOR);
             }
-            const addrs = await import_local.LocalMark.Instance().get_many_address_availables(
-              this.data.progress_new.repository.objects
-            );
-            (0, import_progress.context_repository_remove)(
-              tx,
-              progress,
-              object,
-              permission,
-              addrs,
-              passport
-            );
-            break;
-          }
-          case "clear":
-            (0, import_progress.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 (0, import_local2.GetManyAccountOrMark_Address)(
-              this.data.progress_new.progress_namedOperator.operators
-            );
-            (0, import_progress.namedOperator_add)(
-              tx,
-              progress,
-              object,
-              permission,
-              this.data.progress_new.progress_namedOperator.name,
-              r,
-              passport
-            );
-            break;
-          }
-          case "set": {
-            const r = await (0, import_local2.GetManyAccountOrMark_Address)(
-              this.data.progress_new.progress_namedOperator.operators
-            );
-            (0, import_progress.namedOperator_set)(
-              tx,
-              progress,
-              object,
-              permission,
-              this.data.progress_new.progress_namedOperator.name,
-              r,
-              passport
-            );
-            break;
-          }
-          case "remove": {
-            const r = await (0, import_local2.GetManyAccountOrMark_Address)(
-              this.data.progress_new.progress_namedOperator.operators
-            );
-            (0, import_progress.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(permission_js_1.BuiltinPermissionIndex.MACHINE_DESCRIPTION);
         }
-      }
-      await this.new_with_mark(
-        env,
-        tx,
-        import_object.ObjectType.Progress,
-        (0, import_progress.create)(tx, progress),
-        (0, import_common.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)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.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 import_local.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(permission_js_1.BuiltinPermissionIndex.MACHINE_CONSENSUS_REPOSITORIES);
         }
-        case "remove": {
-          if (this.data.repository.objects.length > (content?.consensus_repositories?.length ?? 0)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `CallService_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`
-            );
-          }
-          const addrs = await import_local.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(permission_js_1.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) {
-            (0, import_exception.W_ERROR)(
-              import_exception.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(permission_js_1.BuiltinPermissionIndex.MACHINE_PAUSE);
         }
-        case "remove": {
-          if (this.data.node.nodes.length > (content?.node_count ?? 0)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.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(permission_js_1.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(permission_js_1.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(permission_js_1.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 (0, import_received.query_received)({
-          object: this.object_address,
-          all_type: true,
-          no_cache: env.no_cache,
-          network: env.network
-        });
-      }
-      await (0, import_util.owner_receive)(
-        tx,
-        object,
-        permission,
-        this.data.owner_receive,
-        void 0,
-        (name) => `${import_common.PackageAddress}::machine::${name}`,
-        passport
-      );
-    }
-    if (this.data.um !== void 0) {
-      let um_address = null;
-      if (this.data.um) {
-        um_address = await import_local.LocalMark.Instance().get_address(this.data.um) || null;
-        if (!um_address) {
-          (0, import_exception.W_ERROR)(
-            import_exception.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 = (0, permission_js_1.newPermission)(tx, this.new_permission_description ?? "");
+            }
+            if (permission) {
+                object = newMachine(tx, (0, common_js_1.toTxObject)(tx, permission), this.data?.description ?? "", passport);
+            }
+        }
+        if (!object || !permission) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallMachine_Data.data.object:" + this.object_address);
+        }
+        if (this.data.progress_new != null) {
+            if (!content) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.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 (0, common_js_1.GetObjectExisted)(this.data.progress_new.task);
+                if (t) {
+                    this.data.progress_new.task = t;
+                }
+                else {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallMachine_Data.data.progress_new.task: ${this.data.progress_new.task} not found`);
+                }
+            }
+            const progress = (0, progress_js_1.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 >
+                            progress_js_1.MAX_CONTEXT_REPOSITORY_COUNT) {
+                            (0, exception_js_1.W_ERROR)(exception_js_1.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") {
+                            (0, progress_js_1.context_repository_clear)(tx, progress, object, permission);
+                        }
+                        const r = await local_js_1.LocalMark.Instance().get_many_address_availables(this.data.progress_new.repository.objects);
+                        r.forEach((repo) => {
+                            (0, progress_js_1.context_repository_add)(tx, progress, object, permission, repo, passport);
+                        });
+                        break;
+                    }
+                    case "remove": {
+                        if (this.data.progress_new.repository.objects.length >
+                            progress_js_1.MAX_CONTEXT_REPOSITORY_COUNT) {
+                            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallProgress_Data.data.progress_new.repository.objects exceeds max count:${this.data.progress_new.repository.objects}`);
+                        }
+                        const addrs = await local_js_1.LocalMark.Instance().get_many_address_availables(this.data.progress_new.repository.objects);
+                        (0, progress_js_1.context_repository_remove)(tx, progress, object, permission, addrs, passport);
+                        break;
+                    }
+                    case "clear":
+                        (0, progress_js_1.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 (0, index_js_1.GetManyAccountOrMark_Address)(this.data.progress_new.progress_namedOperator
+                            .operators);
+                        (0, progress_js_1.namedOperator_add)(tx, progress, object, permission, this.data.progress_new.progress_namedOperator.name, r, passport);
+                        break;
+                    }
+                    case "set": {
+                        const r = await (0, index_js_1.GetManyAccountOrMark_Address)(this.data.progress_new.progress_namedOperator
+                            .operators);
+                        (0, progress_js_1.namedOperator_set)(tx, progress, object, permission, this.data.progress_new.progress_namedOperator.name, r, passport);
+                        break;
+                    }
+                    case "remove": {
+                        const r = await (0, index_js_1.GetManyAccountOrMark_Address)(this.data.progress_new.progress_namedOperator
+                            .operators);
+                        (0, progress_js_1.namedOperator_remove)(tx, progress, object, permission, this.data.progress_new.progress_namedOperator.name, r, passport);
+                        break;
+                    }
+                }
+            }
+            await this.new_with_mark(env, tx, object_js_1.ObjectType.Progress, (0, progress_js_1.create)(tx, progress), (0, common_js_1.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 >
+                        exports.MAX_CONSENSUS_REPOSITORIES_COUNT -
+                            (content?.consensus_repositories?.length ?? 0)) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.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 local_js_1.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)) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallService_Data.data.repository.objects exceeds max count:${this.data.repository.objects}`);
+                    }
+                    const addrs = await local_js_1.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 > exports.MAX_NODE_COUNT) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.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)) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.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);
         }
-      }
-      um_set(tx, object, permission, um_address, passport);
-    }
-    if (!this.permission_address) {
-      const p = (0, import_common.GetObject)(this.data?.object);
-      await this.new_with_mark(
-        env,
-        tx,
-        import_object.ObjectType.Permission,
-        (0, import_permission2.create)(tx, permission),
-        (0, import_common.GetObject)(p.permission)
-      );
-    }
-    if (!this.object_address) {
-      await this.new_with_mark(
-        env,
-        tx,
-        import_object.ObjectType.Machine,
-        create(tx, object),
-        (0, import_common.GetObject)(this.data?.object)
-      );
-    }
-  }
+        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 (0, received_js_1.query_received)({
+                    object: this.object_address,
+                    all_type: true,
+                    no_cache: env.no_cache,
+                    network: env.network,
+                });
+            }
+            await (0, util_js_1.owner_receive)(tx, object, permission, this.data.owner_receive, undefined, (name) => `${common_js_1.PackageAddress}::machine::${name}`, passport);
+        }
+        // 处理 um
+        if (this.data.um !== undefined) {
+            let um_address = null;
+            if (this.data.um) {
+                um_address =
+                    (await local_js_1.LocalMark.Instance().get_address(this.data.um)) ||
+                        null;
+                if (!um_address) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallMachine_Data.data.um:" + this.data.um);
+                }
+            }
+            um_set(tx, object, permission, um_address, passport);
+        }
+        if (!this.permission_address) {
+            const p = (0, common_js_1.GetObject)(this.data?.object);
+            await this.new_with_mark(env, tx, object_js_1.ObjectType.Permission, (0, permission_js_2.create)(tx, permission), (0, common_js_1.GetObject)(p.permission));
+        }
+        if (!this.object_address) {
+            await this.new_with_mark(env, tx, object_js_1.ObjectType.Machine, create(tx, object), (0, common_js_1.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;
+exports.CallMachine = CallMachine;
+// ================================================
+// 常量定义
+exports.MAX_CONSENSUS_REPOSITORIES_COUNT = 200;
+exports.MAX_FORWARD_ORDER_COUNT = 20;
+exports.MAX_NODE_PAIR_COUNT = 40;
+exports.MAX_NODE_COUNT = 200;
+exports.THRESHOLD_DEFAULT = 0;
 function init_node_name() {
-  return "";
+    return "";
 }
 async function forward(tx, param) {
-  if (typeof param.name === "string" && !(0, import_common.isValidName)(param.name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidName,
-      `Forward name ${param.name} exceeds maximum length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (typeof param.namedOperator === "string" && !(0, import_common.isValidName)(param.namedOperator)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidName,
-      `Named operator ${param.namedOperator} exceeds maximum length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (param.permissionIndex !== void 0 && !(0, import_common.isValidU16)(param.permissionIndex)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidArgType,
-      `Permission index must be between 0 and 65535`
-    );
-  }
-  if (!(0, import_common.isValidU16)(param.weight)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.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)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `One of the "namedOperator" or "permissionIndex" must be provided`
-    );
-  }
-  if (param.guard && param.guard.guard != null) {
-    const guard = await import_local.LocalMark.Instance().get_address(param.guard.guard);
-    if (guard) {
-      param.guard.guard = guard;
-    } else {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.IsValidName,
-        `Guard object ${param.guard.guard} is not a valid wow address`
-      );
-    }
-    if (param.guard.retained_submission != null && !(0, import_common.isValidArray)(param.guard.retained_submission, import_common.isValidU8)) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `Retained submission ${param.guard.retained_submission} must be between 0 and 255`
-      );
+    if (typeof param.name === "string" && !(0, common_js_1.isValidName)(param.name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidName, `Forward name ${param.name} exceeds maximum length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (typeof param.namedOperator === "string" &&
+        !(0, common_js_1.isValidName)(param.namedOperator)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidName, `Named operator ${param.namedOperator} exceeds maximum length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (param.permissionIndex !== undefined &&
+        !(0, common_js_1.isValidU16)(param.permissionIndex)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Permission index must be between 0 and 65535`);
+    }
+    if (!(0, common_js_1.isValidU16)(param.weight)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Weight ${param.weight} must be between 0 and 65535`);
+    }
+    if ((param.namedOperator === null || param.namedOperator === undefined) &&
+        (param.permissionIndex === null || param.permissionIndex === undefined)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `One of the "namedOperator" or "permissionIndex" must be provided`);
+    }
+    if (param.guard && param.guard.guard != null) {
+        const guard = await local_js_1.LocalMark.Instance().get_address(param.guard.guard);
+        if (guard) {
+            param.guard.guard = guard;
+        }
+        else {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidName, `Guard object ${param.guard.guard} is not a valid wow address`);
+        }
+        if (param.guard.retained_submission != null &&
+            !(0, common_js_1.isValidArray)(param.guard.retained_submission, common_js_1.isValidU8)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Retained submission ${param.guard.retained_submission} must be between 0 and 255`);
+        }
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("forward_with_guard"),
+            arguments: [
+                (0, common_js_1.toTxString)(tx, param.name),
+                tx.pure.option("string", param.namedOperator ?? null),
+                tx.pure.option("u16", param.permissionIndex ?? null),
+                tx.pure.u16(param.weight),
+                (0, common_js_1.toTxObject)(tx, param.guard.guard),
+                tx.pure.vector("u8", param.guard.retained_submission ?? []),
+            ],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("forward"),
+            arguments: [
+                (0, common_js_1.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: (0, import_common.machineFn)("forward_with_guard"),
-      arguments: [
-        (0, import_common.toTxString)(tx, param.name),
-        tx.pure.option("string", param.namedOperator ?? null),
-        tx.pure.option("u16", param.permissionIndex ?? null),
-        tx.pure.u16(param.weight),
-        (0, import_common.toTxObject)(tx, param.guard.guard),
-        tx.pure.vector("u8", param.guard.retained_submission ?? [])
-      ]
-    });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.machineFn)("forward"),
-      arguments: [
-        (0, import_common.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 && !(0, import_common.isValidName)(prev_node)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidName,
-      `Previous node name ${prev_node} exceeds maximum length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (typeof param.threshold === "number" && !(0, import_common.isValidU32)(param.threshold)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Threshold ${param.threshold} must be between 0 and 4294967295`
-    );
-  }
-  if (param.forwards.length > MAX_FORWARD_ORDER_COUNT) {
-    (0, import_exception.W_ERROR)(
-      import_exception.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: (0, import_common.machineFn)("nodepair3"),
-      arguments: [
-        (0, import_common.toTxString)(tx, prev_node),
-        tx.pure.option("u32", param.threshold ?? null),
-        tx.makeMoveVec({
-          type: `${import_common.PackageAddress}::machine::Forward`,
-          elements: forwards
-        })
-      ]
-    });
-  } else if (param.forwards.length === 1) {
-    return tx.moveCall({
-      target: (0, import_common.machineFn)("nodepair"),
-      arguments: [
-        (0, import_common.toTxString)(tx, prev_node),
-        tx.pure.option("u32", param.threshold ?? null),
-        await forward(tx, param.forwards[0])
-      ]
-    });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.machineFn)("nodepair2"),
-      arguments: [
-        (0, import_common.toTxString)(tx, prev_node),
-        tx.pure.option("u32", param.threshold ?? null)
-      ]
-    });
-  }
+    if (typeof prev_node === "string" &&
+        prev_node.length > 0 &&
+        !(0, common_js_1.isValidName)(prev_node)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidName, `Previous node name ${prev_node} exceeds maximum length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (typeof param.threshold === "number" && !(0, common_js_1.isValidU32)(param.threshold)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Threshold ${param.threshold} must be between 0 and 4294967295`);
+    }
+    if (param.forwards.length > exports.MAX_FORWARD_ORDER_COUNT) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Forward order count ${param.forwards.length} exceeds maximum count ${exports.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: (0, common_js_1.machineFn)("nodepair3"),
+            arguments: [
+                (0, common_js_1.toTxString)(tx, prev_node),
+                tx.pure.option("u32", param.threshold ?? null),
+                tx.makeMoveVec({
+                    type: `${common_js_1.PackageAddress}::machine::Forward`,
+                    elements: forwards,
+                }),
+            ],
+        });
+    }
+    else if (param.forwards.length === 1) {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("nodepair"),
+            arguments: [
+                (0, common_js_1.toTxString)(tx, prev_node),
+                tx.pure.option("u32", param.threshold ?? null),
+                await forward(tx, param.forwards[0]),
+            ],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("nodepair2"),
+            arguments: [
+                (0, common_js_1.toTxString)(tx, prev_node),
+                tx.pure.option("u32", param.threshold ?? null),
+            ],
+        });
+    }
 }
 async function node(tx, param) {
-  if (typeof param.name === "string" && !(0, import_common.isValidName)(param.name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidName,
-      `Node name ${param.name} exceeds maximum length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (param.name === init_node_name()) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Node name ${param.name} is reserved`);
-  }
-  if (param.pairs.length > MAX_NODE_PAIR_COUNT) {
-    (0, import_exception.W_ERROR)(
-      import_exception.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: (0, import_common.machineFn)("node3"),
-      arguments: [
-        (0, import_common.toTxString)(tx, param.name),
-        tx.makeMoveVec({
-          type: `${import_common.PackageAddress}::machine::NodePair`,
-          elements: pairs
-        })
-      ]
-    });
-  } else if (param.pairs.length === 1) {
-    return tx.moveCall({
-      target: (0, import_common.machineFn)("node"),
-      arguments: [
-        (0, import_common.toTxString)(tx, param.name),
-        await nodepair(tx, param.pairs[0].prev_node, param.pairs[0])
-      ]
-    });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.machineFn)("node2"),
-      arguments: [(0, import_common.toTxString)(tx, param.name)]
-    });
-  }
+    if (typeof param.name === "string" && !(0, common_js_1.isValidName)(param.name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidName, `Node name ${param.name} exceeds maximum length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (param.name === init_node_name()) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node name ${param.name} is reserved`);
+    }
+    if (param.pairs.length > exports.MAX_NODE_PAIR_COUNT) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node pair count ${param.pairs.length} exceeds maximum count ${exports.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: (0, common_js_1.machineFn)("node3"),
+            arguments: [
+                (0, common_js_1.toTxString)(tx, param.name),
+                tx.makeMoveVec({
+                    type: `${common_js_1.PackageAddress}::machine::NodePair`,
+                    elements: pairs,
+                }),
+            ],
+        });
+    }
+    else if (param.pairs.length === 1) {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("node"),
+            arguments: [
+                (0, common_js_1.toTxString)(tx, param.name),
+                await nodepair(tx, param.pairs[0].prev_node, param.pairs[0]),
+            ],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("node2"),
+            arguments: [(0, common_js_1.toTxString)(tx, param.name)],
+        });
+    }
 }
 function create(tx, machine) {
-  return tx.moveCall({
-    target: (0, import_common.machineFn)("create"),
-    arguments: [(0, import_common.toTxObject)(tx, machine)]
-  });
-}
-function newMachine(tx, permission, description, passport) {
-  (0, import_util.validObjects)([permission]);
-  if (typeof description === "string" && !(0, import_common.isValidDescription)(description)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidDescription,
-      `Description exceeds maximum length`
-    );
-  }
-  if (passport) {
     return tx.moveCall({
-      target: (0, import_common.machineFn)("new_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        (0, import_common.toTxString)(tx, description),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
+        target: (0, common_js_1.machineFn)("create"),
+        arguments: [(0, common_js_1.toTxObject)(tx, machine)],
     });
-  } else {
-    return tx.moveCall({
-      target: (0, import_common.machineFn)("new"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxString)(tx, description),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
-    });
-  }
+}
+// ================================================
+// 构造函数和设置函数
+function newMachine(tx, permission, description, passport) {
+    (0, util_js_1.validObjects)([permission]);
+    if (typeof description === "string" && !(0, common_js_1.isValidDescription)(description)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidDescription, `Description exceeds maximum length`);
+    }
+    if (passport) {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("new_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: (0, common_js_1.machineFn)("new"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
 }
 function description_set(tx, machine, permission, description, passport) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (typeof description === "string" && !(0, import_common.isValidDescription)(description)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidDescription,
-      `Description exceeds maximum length`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("description_set_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        (0, import_common.toTxString)(tx, description)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("description_set"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxString)(tx, description)
-      ]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (typeof description === "string" && !(0, common_js_1.isValidDescription)(description)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidDescription, `Description exceeds maximum length`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("description_set_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, description),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("description_set"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, description),
+            ],
+        });
+    }
 }
-function node_add(tx, machine, permission, node2, bCompleteReplace, passport) {
-  if (node2.length === 0) {
-    return;
-  }
-  (0, import_util.validObjects)([machine, permission]);
-  if (passport) {
-    if (node2.length > 1) {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_add2_with_passport"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          (0, import_common.toTxObject)(tx, passport),
-          tx.makeMoveVec({
-            type: `${import_common.PackageAddress}::machine::Node`,
-            elements: node2
-          }),
-          tx.pure.bool(bCompleteReplace)
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_add_with_passport"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          (0, import_common.toTxObject)(tx, passport),
-          node2[0],
-          tx.pure.bool(bCompleteReplace)
-        ]
-      });
-    }
-  } else {
-    if (node2.length > 1) {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_add2"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          tx.makeMoveVec({
-            type: `${import_common.PackageAddress}::machine::Node`,
-            elements: node2
-          }),
-          tx.pure.bool(bCompleteReplace)
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_add"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          node2[0],
-          tx.pure.bool(bCompleteReplace)
-        ]
-      });
-    }
-  }
+function node_add(tx, machine, permission, node, bCompleteReplace, passport) {
+    if (node.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (passport) {
+        if (node.length > 1) {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_add2_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    tx.makeMoveVec({
+                        type: `${common_js_1.PackageAddress}::machine::Node`,
+                        elements: node,
+                    }),
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_add_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    node[0],
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+    }
+    else {
+        if (node.length > 1) {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_add2"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    tx.makeMoveVec({
+                        type: `${common_js_1.PackageAddress}::machine::Node`,
+                        elements: node,
+                    }),
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_add"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    node[0],
+                    tx.pure.bool(bCompleteReplace),
+                ],
+            });
+        }
+    }
 }
 function um_set(tx, machine, permission, um, passport) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (um) {
-    if (passport) {
-      tx.moveCall({
-        target: (0, import_common.machineFn)(`um_set_with_passport`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          passport,
-          (0, import_common.toTxObject)(tx, um),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.machineFn)(`um_set`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          (0, import_common.toTxObject)(tx, um),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ]
-      });
-    }
-  } else {
-    if (passport) {
-      tx.moveCall({
-        target: (0, import_common.machineFn)(`um_none_with_passport`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          passport,
-          tx.object.mutRegistrar()
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.machineFn)(`um_none`),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          tx.object.mutRegistrar()
-        ]
-      });
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (um) {
+        if (passport) {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)(`um_set_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    (0, common_js_1.toTxObject)(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)(`um_set`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+            });
+        }
+    }
+    else {
+        if (passport) {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)(`um_none_with_passport`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    passport,
+                    tx.object.mutRegistrar(),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)(`um_none`),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    tx.object.mutRegistrar(),
+                ],
+            });
+        }
     }
-  }
 }
-function node_remove(tx, machine, permission, node2, passport) {
-  if (node2.length === 0) {
-    return;
-  }
-  (0, import_util.validObjects)([machine, permission]);
-  if (passport) {
-    if (node2.length > 1) {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_remove_with_passport"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          (0, import_common.toTxObject)(tx, passport),
-          tx.pure.vector("string", node2)
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_remove_with_passport"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          (0, import_common.toTxObject)(tx, passport),
-          tx.pure.string(node2[0])
-        ]
-      });
-    }
-  } else {
-    if (node2.length > 1) {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_remove"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          tx.pure.vector("string", node2)
-        ]
-      });
-    } else {
-      tx.moveCall({
-        target: (0, import_common.machineFn)("node_remove"),
-        arguments: [
-          (0, import_common.toTxObject)(tx, machine),
-          (0, import_common.toTxObject)(tx, permission),
-          tx.pure.string(node2[0])
-        ]
-      });
+function node_remove(tx, machine, permission, node, passport) {
+    if (node.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (passport) {
+        if (node.length > 1) {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_remove_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    tx.pure.vector("string", node),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_remove_with_passport"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    (0, common_js_1.toTxObject)(tx, passport),
+                    tx.pure.string(node[0]),
+                ],
+            });
+        }
+    }
+    else {
+        if (node.length > 1) {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_remove"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    tx.pure.vector("string", node),
+                ],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: (0, common_js_1.machineFn)("node_remove"),
+                arguments: [
+                    (0, common_js_1.toTxObject)(tx, machine),
+                    (0, common_js_1.toTxObject)(tx, permission),
+                    tx.pure.string(node[0]),
+                ],
+            });
+        }
     }
-  }
 }
 function node_rename(tx, machine, permission, node_name, node_new_name, passport) {
-  if (!node_name || !node_new_name) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Node name ${node_name} or new node name ${node_new_name} is empty`
-    );
-  }
-  (0, import_util.validObjects)([machine, permission]);
-  if (!(0, import_common.isValidName)(node_name)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Node name ${node_name} is invalid`);
-  }
-  if (!(0, import_common.isValidName)(node_new_name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `New node name ${node_new_name} is invalid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("node_rename_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        tx.pure.string(node_name),
-        tx.pure.string(node_new_name)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("node_rename"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.string(node_name),
-        tx.pure.string(node_new_name)
-      ]
-    });
-  }
+    if (!node_name || !node_new_name) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node name ${node_name} or new node name ${node_new_name} is empty`);
+    }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (!(0, common_js_1.isValidName)(node_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node name ${node_name} is invalid`);
+    }
+    if (!(0, common_js_1.isValidName)(node_new_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `New node name ${node_new_name} is invalid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("node_rename_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.string(node_name),
+                tx.pure.string(node_new_name),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("node_rename"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.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) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (!node_one || !node_other) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Node one ${node_one} or node other ${node_other} is empty`
-    );
-  }
-  if (!(0, import_common.isValidName)(node_one)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Node one ${node_one} is invalid`);
-  }
-  if (!(0, import_common.isValidName)(node_other)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Node other ${node_other} is invalid`);
-  }
-  if (node_one === node_other) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Node one ${node_one} and node other ${node_other} are same`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("node_exchange_name_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        tx.pure.string(node_one),
-        tx.pure.string(node_other)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("node_exchange_name"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.string(node_one),
-        tx.pure.string(node_other)
-      ]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (!node_one || !node_other) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node one ${node_one} or node other ${node_other} is empty`);
+    }
+    if (!(0, common_js_1.isValidName)(node_one)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node one ${node_one} is invalid`);
+    }
+    if (!(0, common_js_1.isValidName)(node_other)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node other ${node_other} is invalid`);
+    }
+    if (node_one === node_other) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Node one ${node_one} and node other ${node_other} are same`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("node_exchange_name_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.string(node_one),
+                tx.pure.string(node_other),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("node_exchange_name"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.string(node_one),
+                tx.pure.string(node_other),
+            ],
+        });
+    }
 }
 function node_clear(tx, machine, permission, passport) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("node_clear_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("node_clear"),
-      arguments: [(0, import_common.toTxObject)(tx, machine), (0, import_common.toTxObject)(tx, permission)]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("node_clear_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("node_clear"),
+            arguments: [(0, common_js_1.toTxObject)(tx, machine), (0, common_js_1.toTxObject)(tx, permission)],
+        });
+    }
 }
 function publish(tx, machine, permission, passport) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("publish_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("publish"),
-      arguments: [(0, import_common.toTxObject)(tx, machine), (0, import_common.toTxObject)(tx, permission)]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("publish_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("publish"),
+            arguments: [(0, common_js_1.toTxObject)(tx, machine), (0, common_js_1.toTxObject)(tx, permission)],
+        });
+    }
 }
 function pause(tx, machine, permission, bPaused, passport) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("pause_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        tx.pure.bool(bPaused)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("pause"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.bool(bPaused)
-      ]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("pause_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.bool(bPaused),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("pause"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.bool(bPaused),
+            ],
+        });
+    }
 }
 function consensus_repositories_add(tx, machine, permission, repository, passport) {
-  (0, import_util.validObjects)([machine, permission, repository]);
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("consensus_repositories_add_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        (0, import_common.toTxObject)(tx, repository),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("consensus_repositories_add"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, repository),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission, repository]);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("consensus_repositories_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxObject)(tx, repository),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("consensus_repositories_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, repository),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+        });
+    }
 }
 function consensus_repositories_remove(tx, machine, permission, repositories, passport) {
-  if (!repositories || repositories.length === 0) {
-    return;
-  }
-  (0, import_util.validObjects)([machine, permission, ...repositories]);
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("consensus_repositories_remove_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        tx.pure.vector("string", repositories),
-        tx.object.mutRegistrar()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("consensus_repositories_remove"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.pure.vector("string", repositories),
-        tx.object.mutRegistrar()
-      ]
-    });
-  }
+    if (!repositories || repositories.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([machine, permission, ...repositories]);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("consensus_repositories_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.pure.vector("string", repositories),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("consensus_repositories_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                tx.pure.vector("string", repositories),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
 }
 function consensus_repositories_clear(tx, machine, permission, passport) {
-  (0, import_util.validObjects)([machine, permission]);
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("consensus_repositories_clear_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        tx.object.mutRegistrar()
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("consensus_repositories_clear"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        tx.object.mutRegistrar()
-      ]
-    });
-  }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("consensus_repositories_clear_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("consensus_repositories_clear"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.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;
-  }
-  (0, import_util.validObjects)([machine, permission]);
-  if (threshold !== null && !(0, import_common.isValidU32)(threshold)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `threshold ${threshold} must be u32`);
-  }
-  if (!(0, import_common.isValidName)(node_name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `node_name ${node_name} is excceed max length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (!(0, import_common.isValidName)(next_node_name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `next_node_name ${next_node_name} is excceed max length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("forwards_add_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        (0, import_common.toTxString)(tx, node_name),
-        (0, import_common.toTxString)(tx, next_node_name),
-        tx.makeMoveVec({
-          type: `${import_common.PackageAddress}::machine::Forward`,
-          elements: forwards
-        }),
-        tx.pure.option("u32", threshold ?? null)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("forwards_add"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxString)(tx, node_name),
-        (0, import_common.toTxString)(tx, next_node_name),
-        tx.makeMoveVec({
-          type: `${import_common.PackageAddress}::machine::Forward`,
-          elements: forwards
-        }),
-        tx.pure.option("u32", threshold ?? null)
-      ]
-    });
-  }
+    if (!forwards || forwards.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (threshold !== null && !(0, common_js_1.isValidU32)(threshold)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `threshold ${threshold} must be u32`);
+    }
+    if (!(0, common_js_1.isValidName)(node_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `node_name ${node_name} is excceed max length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidName)(next_node_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `next_node_name ${next_node_name} is excceed max length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("forwards_add_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, node_name),
+                (0, common_js_1.toTxString)(tx, next_node_name),
+                tx.makeMoveVec({
+                    type: `${common_js_1.PackageAddress}::machine::Forward`,
+                    elements: forwards,
+                }),
+                tx.pure.option("u32", threshold ?? null),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("forwards_add"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, node_name),
+                (0, common_js_1.toTxString)(tx, next_node_name),
+                tx.makeMoveVec({
+                    type: `${common_js_1.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;
-  }
-  (0, import_util.validObjects)([machine, permission, ...forwards]);
-  if (!(0, import_common.isValidName)(node_name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `node_name ${node_name} is excceed max length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (!(0, import_common.isValidName)(next_node_name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `next_node_name ${next_node_name} is excceed max length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  if (threshold !== null && !(0, import_common.isValidU32)(threshold)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `threshold ${threshold} must be u32`);
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("forwards_remove_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        (0, import_common.toTxString)(tx, node_name),
-        (0, import_common.toTxString)(tx, next_node_name),
-        tx.pure.vector("string", forwards),
-        tx.pure.option("u32", threshold ?? null)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("forwards_remove"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxString)(tx, node_name),
-        (0, import_common.toTxString)(tx, next_node_name),
-        tx.pure.vector("string", forwards),
-        tx.pure.option("u32", threshold ?? null)
-      ]
-    });
-  }
+    if (!forwards || forwards.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([machine, permission, ...forwards]);
+    if (!(0, common_js_1.isValidName)(node_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `node_name ${node_name} is excceed max length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (!(0, common_js_1.isValidName)(next_node_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `next_node_name ${next_node_name} is excceed max length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    if (threshold !== null && !(0, common_js_1.isValidU32)(threshold)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `threshold ${threshold} must be u32`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("forwards_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, node_name),
+                (0, common_js_1.toTxString)(tx, next_node_name),
+                tx.pure.vector("string", forwards),
+                tx.pure.option("u32", threshold ?? null),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("forwards_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, node_name),
+                (0, common_js_1.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;
-  }
-  (0, import_util.validObjects)([machine, permission]);
-  if (!(0, import_common.isValidName)(node_name)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `node_name ${node_name} is excceed max length ${import_common.MAX_NAME_LENGTH}`
-    );
-  }
-  for (const prev_node_name of prev_node_names) {
-    if (!(0, import_common.isValidName)(prev_node_name)) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `prev_node_name ${prev_node_name} is excceed max length ${import_common.MAX_NAME_LENGTH}`
-      );
-    }
-  }
-  if (passport) {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("prev_nodes_remove_with_passport"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxObject)(tx, passport),
-        (0, import_common.toTxString)(tx, node_name),
-        tx.pure.vector("string", prev_node_names)
-      ]
-    });
-  } else {
-    tx.moveCall({
-      target: (0, import_common.machineFn)("prev_nodes_remove"),
-      arguments: [
-        (0, import_common.toTxObject)(tx, machine),
-        (0, import_common.toTxObject)(tx, permission),
-        (0, import_common.toTxString)(tx, node_name),
-        tx.pure.vector("string", prev_node_names)
-      ]
-    });
-  }
+    if (prev_node_names.length === 0) {
+        return;
+    }
+    (0, util_js_1.validObjects)([machine, permission]);
+    if (!(0, common_js_1.isValidName)(node_name)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `node_name ${node_name} is excceed max length ${common_js_1.MAX_NAME_LENGTH}`);
+    }
+    for (const prev_node_name of prev_node_names) {
+        if (!(0, common_js_1.isValidName)(prev_node_name)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `prev_node_name ${prev_node_name} is excceed max length ${common_js_1.MAX_NAME_LENGTH}`);
+        }
+    }
+    if (passport) {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("prev_nodes_remove_with_passport"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxObject)(tx, passport),
+                (0, common_js_1.toTxString)(tx, node_name),
+                tx.pure.vector("string", prev_node_names),
+            ],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: (0, common_js_1.machineFn)("prev_nodes_remove"),
+            arguments: [
+                (0, common_js_1.toTxObject)(tx, machine),
+                (0, common_js_1.toTxObject)(tx, permission),
+                (0, common_js_1.toTxString)(tx, node_name),
+                tx.pure.vector("string", prev_node_names),
+            ],
+        });
+    }
 }
 const machineNode2file = async (machine, file_path, format = "json", network) => {
-  const machineAddr = await import_local.LocalMark.Instance().get_address(machine);
-  if (!machineAddr) {
-    throw new Error(`Machine object ${machine} not found`);
-  }
-  const machineQueryResult = await (0, import_object.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 (0, import_object.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 (0, import_object.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
+    // Get machine address
+    const machineAddr = await local_js_1.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 (0, object_js_1.query_objects)({
+        objects: [machineAddr],
+        network: 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}`);
+    }
+    // Query all table items (nodes) from the machine
+    const tableQuery = {
+        parent: machineAddr,
+        network: network,
     };
-  });
-  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
-    );
-  }
-  (0, import_fs.writeFileSync)(file_path, content, "utf-8");
+    const tableResult = await (0, object_js_1.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 (0, object_js_1.query_objects)({
+        objects: nodeObjectIds,
+        network: network,
+    });
+    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,
+        };
+    });
+    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
+    (0, fs_1.writeFileSync)(file_path, content, "utf-8");
 };
+exports.machineNode2file = machineNode2file;
 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) {
-  (0, import_util.validObjects)([machine, permission, passport]);
-  tx.moveCall({
-    target: (0, import_common.machineFn)("prev_nodes_remove_with_passport"),
-    arguments: [
-      (0, import_common.toTxObject)(tx, machine),
-      (0, import_common.toTxObject)(tx, permission),
-      (0, import_common.toTxObject)(tx, passport),
-      (0, import_common.toTxString)(tx, node_name),
-      tx.pure.vector("string", prev_node_names)
-    ]
-  });
+    (0, util_js_1.validObjects)([machine, permission, passport]);
+    tx.moveCall({
+        target: (0, common_js_1.machineFn)("prev_nodes_remove_with_passport"),
+        arguments: [
+            (0, common_js_1.toTxObject)(tx, machine),
+            (0, common_js_1.toTxObject)(tx, permission),
+            (0, common_js_1.toTxObject)(tx, passport),
+            (0, common_js_1.toTxString)(tx, node_name),
+            tx.pure.vector("string", prev_node_names),
+        ],
+    });
 }
+//# sourceMappingURL=machine.js.map