wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1486 @@
+"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`
+          );
+        }
+      }
+      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.data.progress_new.repository.op === "set") {
+              (0, import_progress.context_repository_clear)(
+                tx,
+                progress,
+                object,
+                permission
+              );
+            }
+            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 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;
+          }
+        }
+      }
+      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;
+        }
+        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;
+        }
+        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;
+        }
+        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;
+        }
+        case "clear":
+          node_clear(tx, object, permission, passport);
+          break;
+        case "exchange":
+          node_exchange_name(
+            tx,
+            object,
+            permission,
+            this.data.node.node_one,
+            this.data.node.node_other,
+            passport
+          );
+          break;
+        case "rename":
+          node_rename(
+            tx,
+            object,
+            permission,
+            this.data.node.node_name_old,
+            this.data.node.node_name_new,
+            passport
+          );
+          break;
+        case "add forward": {
+          for (const item of this.data.node.data) {
+            const f = await Promise.all(
+              item.forward.map(async (f2) => await forward(tx, f2))
+            );
+            await forwards_add(
+              tx,
+              object,
+              permission,
+              item.prior_node_name,
+              item.node_name,
+              f,
+              item.threshold ?? null
+            );
+          }
+          break;
+        }
+        case "remove forward": {
+          for (const item of this.data.node.data) {
+            forwards_remove(
+              tx,
+              object,
+              permission,
+              item.prior_node_name,
+              item.node_name,
+              item.forward_name,
+              null
+            );
+          }
+          break;
+        }
+        case "remove prior node": {
+          for (const item of this.data.node.pairs) {
+            prev_nodes_remove(
+              tx,
+              object,
+              permission,
+              item.node_name,
+              item.prior_node_name
+            );
+          }
+          break;
+        }
+      }
+    }
+    if (this.data.pause != null) {
+      pause(
+        tx,
+        object,
+        permission,
+        this.data.pause ? true : false,
+        passport
+      );
+    }
+    if (this.data.publish != null) {
+      publish(tx, object, permission, passport);
+    }
+    if (this.data.owner_receive != null && this.object_address) {
+      if (this.data.owner_receive === "recently") {
+        this.data.owner_receive = await (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
+          );
+        }
+      }
+      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)
+      );
+    }
+  }
+}
+const MAX_CONSENSUS_REPOSITORIES_COUNT = 200;
+const MAX_FORWARD_ORDER_COUNT = 20;
+const MAX_NODE_PAIR_COUNT = 40;
+const MAX_NODE_COUNT = 200;
+const THRESHOLD_DEFAULT = 0;
+function init_node_name() {
+  return "";
+}
+async function forward(tx, param) {
+  if (typeof param.name === "string" && !(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`
+      );
+    }
+    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)
+      ]
+    });
+  }
+}
+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)]
+    });
+  }
+}
+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()
+      ]
+    });
+  } 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 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)
+      ]
+    });
+  }
+}
+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 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()
+        ]
+      });
+    }
+  }
+}
+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_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)
+      ]
+    });
+  }
+}
+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)
+      ]
+    });
+  }
+}
+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)]
+    });
+  }
+}
+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)]
+    });
+  }
+}
+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)
+      ]
+    });
+  }
+}
+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()
+      ]
+    });
+  }
+}
+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()
+      ]
+    });
+  }
+}
+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()
+      ]
+    });
+  }
+}
+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)
+      ]
+    });
+  }
+}
+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)
+      ]
+    });
+  }
+}
+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)
+      ]
+    });
+  }
+}
+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
+    };
+  });
+  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");
+};
+function generateMachineNodeMarkdown(nodes, machineName, machineAddr, machineId) {
+  let md = `# Machine Node Definition
+
+`;
+  md += `**Machine:** ${machineName}
+
+`;
+  md += `**Address:** ${machineAddr}
+
+`;
+  if (machineId) {
+    md += `**ID:** ${machineId}
+
+`;
+  }
+  md += `**Total Nodes:** ${nodes.length}
+
+`;
+  md += `---
+
+`;
+  for (const node2 of nodes) {
+    md += `## Node: ${node2.name}
+
+`;
+    for (const pair of node2.pairs) {
+      md += `### Pair: ${pair.prev_node}
+
+`;
+      md += `- **prev_node**: ${pair.prev_node}
+`;
+      md += `- **threshold**: ${pair.threshold}
+
+`;
+      if (pair.forwards && pair.forwards.length > 0) {
+        md += `#### Forwards
+
+`;
+        md += `| name | weight | namedOperator | permissionIndex | guard |
+`;
+        md += `|------|--------|---------------|-----------------|-------|
+`;
+        for (const forward2 of pair.forwards) {
+          const namedOp = forward2.namedOperator || "";
+          const permIdx = forward2.permissionIndex?.toString() || "";
+          const guard = forward2.guard?.guard || "";
+          md += `| ${forward2.name} | ${forward2.weight} | ${namedOp} | ${permIdx} | ${guard} |
+`;
+        }
+        md += `
+`;
+      }
+    }
+    md += `---
+
+`;
+  }
+  md += `## JSON Definition
+
+`;
+  md += `\`\`\`json
+`;
+  md += JSON.stringify(nodes, null, 2);
+  md += `
+\`\`\`
+`;
+  return md;
+}
+function prev_nodes_remove_with_passport(tx, machine, permission, passport, node_name, prev_node_names) {
+  (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)
+    ]
+  });
+}