@xyo-network/xl1-cli-lib 1.8.4 → 1.10.0

package/dist/node/index.mjs

@@ -1,5 +1,13 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 
 // src/orchestration/actor/implementation/BalanceActor.ts
 import { assertEx } from "@xylabs/assert";
@@ -12,19 +20,13 @@ import { forget } from "@xylabs/forget";
 import { IdLogger } from "@xylabs/logger";
 import { span, spanAsync } from "@xylabs/telemetry";
 var Actor = class extends Base {
-  static {
-    __name(this, "Actor");
-  }
   _timers = /* @__PURE__ */ new Map();
   _active = false;
   _displayName;
   _id;
   constructor(id, displayName = "Actor", params) {
     const logger = params.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `);
-    super({
-      ...params,
-      logger
-    });
+    super({ ...params, logger });
     this._displayName = displayName;
     this._id = id;
   }
@@ -41,29 +43,29 @@ var Actor = class extends Base {
     return `[${this.displayName} (${this.id})] `;
   }
   /**
-  * The timer runs until the actor is deactivated (or you manually stop it).
-  */
+   * The timer runs until the actor is deactivated (or you manually stop it).
+   */
   registerTimer(timerName, callback, dueTimeMs, periodMs) {
     if (!this._active) {
-      this.logger?.warn(`Cannot register timer '${timerName}' because actor is not active.`);
+      this.logger?.warn(
+        `Cannot register timer '${timerName}' because actor is not active.`
+      );
       return;
     }
-    const schedulePeriodicRun = /* @__PURE__ */ __name(async () => {
+    const schedulePeriodicRun = async () => {
       if (!this._active || !this._timers.has(timerName)) return;
       try {
         await callback();
       } catch (error) {
         this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`);
       } finally {
-        this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), {
-          name: `schedulePeriodicRun:${this.name}:${timerName}`
-        }), periodMs));
+        this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), { name: `schedulePeriodicRun:${this.name}:${timerName}` }), periodMs));
       }
-    }, "schedulePeriodicRun");
-    this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), {
-      name: `schedulePeriodicRun(initial):${this.name}:${timerName}`
-    }), dueTimeMs));
-    this.logger?.log(`Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`);
+    };
+    this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), { name: `schedulePeriodicRun(initial):${this.name}:${timerName}` }), dueTimeMs));
+    this.logger?.log(
+      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`
+    );
   }
   span(name, fn) {
     return span(`${this.name}:${name}`, fn, this.tracer);
@@ -72,17 +74,17 @@ var Actor = class extends Base {
     return await spanAsync(`${this.name}:${name}`, fn, this.tracer);
   }
   /**
-  * Called by the Orchestrator when the actor is activated.
-  */
+   * Called by the Orchestrator when the actor is activated.
+   */
   async start() {
     await Promise.resolve();
     this._active = true;
     this.logger?.log("Started.");
   }
   /**
-  * Called by the Orchestrator when the actor is deactivated.
-  * Stop all running timers.
-  */
+   * Called by the Orchestrator when the actor is deactivated.
+   * Stop all running timers.
+   */
   async stop() {
     await Promise.resolve();
     this._active = false;
@@ -97,9 +99,6 @@ var Actor = class extends Base {
 
 // src/orchestration/actor/model/Orchestrator.ts
 var Orchestrator = class {
-  static {
-    __name(this, "Orchestrator");
-  }
   actors = [];
   keepAliveHandle = null;
   logger;
@@ -108,9 +107,9 @@ var Orchestrator = class {
     this.logger = logger;
   }
   /**
-  * Registers an actor.
-  * (We won't activate the actor until `start()` is called.)
-  */
+   * Registers an actor.
+   * (We won't activate the actor until `start()` is called.)
+   */
   async registerActor(actor) {
     if (this.running) {
       await actor.start();
@@ -118,8 +117,8 @@ var Orchestrator = class {
     this.actors.push(actor);
   }
   /**
-  * Starts the orchestrator: activates all actors.
-  */
+   * Starts the orchestrator: activates all actors.
+   */
   async start() {
     await Promise.resolve();
     if (this.running) {
@@ -135,8 +134,8 @@ var Orchestrator = class {
     }, 2147483647);
   }
   /**
-  * Stops the orchestrator: deactivates all actors.
-  */
+   * Stops the orchestrator: deactivates all actors.
+   */
   async stop() {
     await Promise.resolve();
     if (!this.running) {
@@ -155,9 +154,6 @@ var Orchestrator = class {
 
 // src/orchestration/actor/implementation/BalanceActor.ts
 var BalanceActor = class _BalanceActor extends Actor {
-  static {
-    __name(this, "BalanceActor");
-  }
   _updateMutex = new Mutex();
   constructor(params) {
     super("BalanceActor", "Balance", params);
@@ -196,9 +192,6 @@ import { toHex } from "@xylabs/hex";
 import { findMostRecentBlock, sortBlocks } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitness } from "@xyo-network/xl1-protocol";
 var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
-  static {
-    __name(this, "ChainHeadUpdateActor");
-  }
   constructor(params) {
     super("ChainHeadUpdate", "ChainHeadUpdate", params);
   }
@@ -248,13 +241,14 @@ import { createDeclarationIntent } from "@xyo-network/chain-protocol";
 import { BaseBlockProducerService } from "@xyo-network/chain-services";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
-import { buildTransaction, flattenHydratedBlock, flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
+import {
+  buildTransaction,
+  flattenHydratedBlock,
+  flattenHydratedTransaction
+} from "@xyo-network/xl1-protocol-sdk";
 var SHOULD_REGISTER_REDECLARATION_INTENT_TIMER = true;
 var TEN_MINUTES = 10 * 60 * 1e3;
 var ProducerActor = class _ProducerActor extends Actor {
-  static {
-    __name(this, "ProducerActor");
-  }
   _lastProducedBlock;
   _lastRedeclarationIntent;
   constructor(params) {
@@ -324,15 +318,24 @@ var ProducerActor = class _ProducerActor extends Actor {
             this._lastRedeclarationIntent = void 0;
           }
           if (!await this.validateCurrentBalance()) {
-            this.logger?.error(`Add balance to address ${this.account.address} for the producer to declare it's intent.`);
+            this.logger?.error(
+              `Add balance to address ${this.account.address} for the producer to declare it's intent.`
+            );
             return;
           }
           if (!await this.validateCurrentStake()) {
-            this.logger?.error(`Add stake to contract address ${this.params.config.chain.id} for the producer to declare it's intent.`);
+            this.logger?.error(
+              `Add stake to contract address ${this.params.config.chain.id} for the producer to declare it's intent.`
+            );
             return;
           }
           this.logger?.log("Creating redeclaration intent for producer:", this.account.address);
-          const redeclarationIntent = createDeclarationIntent(this.account.address, "producer", currentBlock, currentBlock + BaseBlockProducerService.RedeclarationDuration);
+          const redeclarationIntent = createDeclarationIntent(
+            this.account.address,
+            "producer",
+            currentBlock,
+            currentBlock + BaseBlockProducerService.RedeclarationDuration
+          );
           await this.submitRedeclarationIntent(currentBlock, redeclarationIntent);
           this._lastRedeclarationIntent = redeclarationIntent;
         });
@@ -342,37 +345,30 @@ var ProducerActor = class _ProducerActor extends Actor {
   async calculateBlocksUntilProducerDeclarationExpiration(currentBlock) {
     const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.account.address, "producer");
     const lastRange = ranges.toSorted((a, b) => a[1] > b[1] ? 1 : -1).at(-1);
-    const [, currentDeclarationEnd] = lastRange || [
-      void 0,
-      currentBlock
-    ];
+    const [, currentDeclarationEnd] = lastRange || [void 0, currentBlock];
     const timeToProducerExpiration = currentDeclarationEnd - currentBlock;
     return timeToProducerExpiration;
   }
   async submitRedeclarationIntent(currentBlock, redeclarationIntent) {
     this.logger?.log("Submitting redeclaration intent for producer:", this.account.address);
-    const tx = await buildTransaction(this.chainIterator.chainId, [
-      redeclarationIntent
-    ], [], this.account, currentBlock, currentBlock + 1e3);
+    const tx = await buildTransaction(
+      this.chainIterator.chainId,
+      [redeclarationIntent],
+      [],
+      this.account,
+      currentBlock,
+      currentBlock + 1e3
+    );
     const payloads = flattenHydratedTransaction(tx);
     const root = tx[0]._hash;
-    const payloadBundle = new PayloadBuilder2({
-      schema: PayloadBundleSchema
-    }).fields({
-      payloads,
-      root
-    }).build();
-    await this.pendingBundledTransactionsArchivistWrite.insert([
-      payloadBundle
-    ]);
+    const payloadBundle = new PayloadBuilder2({ schema: PayloadBundleSchema }).fields({ payloads, root }).build();
+    await this.pendingBundledTransactionsArchivistWrite.insert([payloadBundle]);
     this.logger?.log("Submitted redeclaration intent for producer:", this.account.address);
   }
   async validateCurrentBalance() {
     const head = this._lastProducedBlock?.[0]._hash;
     if (isDefined(head)) {
-      const balances = await this.balanceService.balances(head, [
-        this.account.address
-      ]);
+      const balances = await this.balanceService.balances(head, [this.account.address]);
       const currentBalance = balances[this.account.address] ?? 0n;
       if (currentBalance <= 0n) {
         this.logger?.error(`Producer ${this.account.address} has no balance.`);
@@ -399,9 +395,6 @@ import { toHex as toHex3 } from "@xylabs/hex";
 import { isDefined as isDefined2, isUndefined as isUndefined2 } from "@xylabs/typeof";
 import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
 var ValidatorActor = class _ValidatorActor extends Actor {
-  static {
-    __name(this, "ValidatorActor");
-  }
   _lastValidatedBlock;
   _lastValidatedBlockHash;
   constructor(params) {
@@ -471,24 +464,16 @@ var ValidatorActor = class _ValidatorActor extends Actor {
 // src/orchestration/health/initHealthEndpoints.ts
 import http from "http";
 import { isDefined as isDefined3 } from "@xylabs/typeof";
-var sendStatus = /* @__PURE__ */ __name((res, status, errorCode) => {
+var sendStatus = (res, status, errorCode) => {
   const statusCode = status === "started" ? 200 : errorCode;
-  res.writeHead(statusCode, {
-    "Content-Type": "application/json"
-  });
-  res.end(JSON.stringify({
-    status
-  }));
-}, "sendStatus");
-var notFound = /* @__PURE__ */ __name((res) => {
-  res.writeHead(404, {
-    "Content-Type": "application/json"
-  });
-  res.end(JSON.stringify({
-    status: "not found"
-  }));
-}, "notFound");
-var createHealthServer = /* @__PURE__ */ __name((port, statusMonitor, logger) => {
+  res.writeHead(statusCode, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ status }));
+};
+var notFound = (res) => {
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ status: "not found" }));
+};
+var createHealthServer = (port, statusMonitor, logger) => {
   const server = http.createServer((req, res) => {
     const url = req.url ?? "";
     const status = statusMonitor.getGlobalStatus();
@@ -517,12 +502,16 @@ var createHealthServer = /* @__PURE__ */ __name((port, statusMonitor, logger) =>
     logger.log(" - /readyz");
   });
   return server;
-}, "createHealthServer");
-var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
-  const { config: config3, logger, statusReporter } = params;
+};
+var initHealthEndpoints = (params) => {
+  const {
+    config: config3,
+    logger,
+    statusReporter
+  } = params;
   const { healthCheckPort } = config3.producer;
   return isDefined3(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
-}, "initHealthEndpoints");
+};
 
 // src/orchestration/initServices.ts
 import { assertEx as assertEx17 } from "@xylabs/assert";
@@ -548,13 +537,13 @@ import { LmdbArchivist, LmdbArchivistConfigSchema } from "@xyo-network/archivist
 
 // src/orchestration/store/getStoreDirectory.ts
 import Path from "path";
-var getStoreDirectory = /* @__PURE__ */ __name((name, storageRoot, kind) => {
+var getStoreDirectory = (name, storageRoot, kind) => {
   return kind === void 0 ? Path.join(storageRoot, name) : Path.join(storageRoot, kind, name);
-}, "getStoreDirectory");
+};
 
 // src/orchestration/archivists/lib/localPersistentArchivist.ts
 var DEFAULT_STORAGE_ROOT = Path2.join(process.cwd(), ".store");
-var getLocalPersistentArchivist = /* @__PURE__ */ __name((dbName, storeName, storageRoot, kind = "lmdb") => {
+var getLocalPersistentArchivist = (dbName, storeName, storageRoot, kind = "lmdb") => {
   switch (kind) {
     case "lmdb": {
       const root = storageRoot ?? DEFAULT_STORAGE_ROOT;
@@ -570,19 +559,19 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((dbName, storeName, sto
       });
     }
   }
-}, "getLocalPersistentArchivist");
+};
 
 // src/orchestration/archivists/ChainFinalized/local.ts
 var mutex = new Mutex2();
 var singleton;
-var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initLocalChainFinalizedArchivist = async ({ config: config3 }) => {
   return await mutex.runExclusive(async () => {
     if (singleton) return singleton;
     const { root } = config3.storage;
     singleton = await getLocalPersistentArchivist("chain", "finalized", root);
     return singleton;
   });
-}, "initLocalChainFinalizedArchivist");
+};
 
 // src/orchestration/archivists/ChainFinalized/remote.ts
 import { assertEx as assertEx5 } from "@xylabs/assert";
@@ -591,42 +580,39 @@ import { getUrl } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
 var mutex2 = new Mutex3();
 var singleton2;
-var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initRemoteChainFinalizedArchivist = async ({ config: config3 }) => {
   return await mutex2.runExclusive(async () => {
     if (singleton2) return singleton2;
     const { host, port } = config3.api;
     const nodeUrl = getUrl(host, port);
     const bridge = await initBridge(nodeUrl);
-    singleton2 = await initBridgedArchivistModule({
-      bridge,
-      moduleName: "XYOChain:Chain:Finalized"
-    });
+    singleton2 = await initBridgedArchivistModule({ bridge, moduleName: "XYOChain:Chain:Finalized" });
     return assertEx5(singleton2, () => "Error: RemoteChainFinalizedArchivist failed to initialize");
   });
-}, "initRemoteChainFinalizedArchivist");
+};
 
 // src/orchestration/archivists/ChainFinalized/archivist.ts
 var mutex3 = new Mutex4();
 var singleton3;
-async function initChainFinalizedArchivist({ config: config3, logger, traceProvider }) {
+async function initChainFinalizedArchivist({
+  config: config3,
+  logger,
+  traceProvider
+}) {
   return await mutex3.runExclusive(async () => {
     if (singleton3) return singleton3;
     const [remote, local] = await Promise.all([
-      startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist({
-        config: config3,
-        logger
-      })),
-      startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
-        config: config3,
-        logger
-      }))
+      startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist({ config: config3, logger })),
+      startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({ config: config3, logger }))
     ]);
-    await startupSpanAsync("ChainFinalizedArchivist:initArchivistSync", () => initArchivistSync("ChainFinalizedArchivist", remote, local, 200, Number.MAX_SAFE_INTEGER, traceProvider));
+    await startupSpanAsync(
+      "ChainFinalizedArchivist:initArchivistSync",
+      () => initArchivistSync("ChainFinalizedArchivist", remote, local, 200, Number.MAX_SAFE_INTEGER, traceProvider)
+    );
     singleton3 = local;
     return singleton3;
   });
 }
-__name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
 
 // src/orchestration/archivists/ChainSubmissions/archivist.ts
 import { assertEx as assertEx7 } from "@xylabs/assert";
@@ -640,31 +626,28 @@ import { getUrl as getUrl2 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex5 } from "async-mutex";
 var mutex4 = new Mutex5();
 var singleton4;
-var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initRemoteChainSubmissionsArchivist = async ({ config: config3 }) => {
   return await mutex4.runExclusive(async () => {
     if (singleton4) return singleton4;
     const { host, port } = config3.api;
     const nodeUrl = getUrl2(host, port);
     const bridge = await initBridge2(nodeUrl);
-    singleton4 = await initBridgedArchivistModule2({
-      bridge,
-      moduleName: "XYOChain:Chain:Submissions"
-    });
+    singleton4 = await initBridgedArchivistModule2({ bridge, moduleName: "XYOChain:Chain:Submissions" });
     return assertEx6(singleton4, () => new Error("Failed to initialize RemoteChainSubmissionsArchivist"));
   });
-}, "initRemoteChainSubmissionsArchivist");
+};
 
 // src/orchestration/archivists/ChainSubmissions/archivist.ts
 var mutex5 = new Mutex6();
 var singleton5;
-var initChainSubmissionsArchivist = /* @__PURE__ */ __name(async (params) => {
+var initChainSubmissionsArchivist = async (params) => {
   return await mutex5.runExclusive(async () => {
     if (singleton5) return singleton5;
     const remote = await startupSpanAsync2("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist(params));
     singleton5 = remote;
     return assertEx7(singleton5, () => new Error("Failed to initialize ChainSubmissionsArchivist"));
   });
-}, "initChainSubmissionsArchivist");
+};
 
 // src/orchestration/archivists/PendingTransactions/archivist.ts
 import { initArchivistSync as initArchivistSync2 } from "@xyo-network/chain-orchestration";
@@ -676,7 +659,7 @@ import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archi
 import { Mutex as Mutex7 } from "async-mutex";
 var mutex6 = new Mutex7();
 var singleton6;
-var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+var initLocalPendingTransactionsArchivist = async () => {
   return await mutex6.runExclusive(async () => {
     if (singleton6) return singleton6;
     singleton6 = await MemoryArchivist.create({
@@ -689,7 +672,7 @@ var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
     });
     return singleton6;
   });
-}, "initLocalPendingTransactionsArchivist");
+};
 
 // src/orchestration/archivists/PendingTransactions/remote.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
@@ -698,41 +681,35 @@ import { getUrl as getUrl3 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex8 } from "async-mutex";
 var mutex7 = new Mutex8();
 var singleton7;
-var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initRemotePendingTransactionsArchivist = async ({ config: config3 }) => {
   return await mutex7.runExclusive(async () => {
     if (singleton7) return singleton7;
     const { host, port } = config3.api;
     const nodeUrl = getUrl3(host, port);
     const bridge = await initBridge3(nodeUrl);
-    singleton7 = await initBridgedArchivistModule3({
-      bridge,
-      moduleName: "XYOChain:Pending:PendingTransactions"
-    });
+    singleton7 = await initBridgedArchivistModule3({ bridge, moduleName: "XYOChain:Pending:PendingTransactions" });
     return assertEx8(singleton7, () => "Error: RemotePendingBundledTransactionsArchivist is undefined");
   });
-}, "initRemotePendingTransactionsArchivist");
+};
 
 // src/orchestration/archivists/PendingTransactions/archivist.ts
 var mutex8 = new Mutex9();
 var singleton8;
-var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(async (params) => {
+var initPendingBundledTransactionsArchivist = async (params) => {
   return await mutex8.runExclusive(async () => {
     if (singleton8) return singleton8;
     const remote = await startupSpanAsync3("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist(params));
     const local = await startupSpanAsync3("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist(params));
-    const start2 = await remote.next({
-      limit: 1,
-      order: "desc"
-    });
+    const start2 = await remote.next({ limit: 1, order: "desc" });
     await local.insert(start2);
-    await startupSpanAsync3("PendingBundledTransactionsArchivist:initArchivistSync", () => initArchivistSync2("PendingBundledTransactionsArchivist", remote, local));
-    singleton8 = [
-      local,
-      remote
-    ];
+    await startupSpanAsync3(
+      "PendingBundledTransactionsArchivist:initArchivistSync",
+      () => initArchivistSync2("PendingBundledTransactionsArchivist", remote, local)
+    );
+    singleton8 = [local, remote];
     return singleton8;
   });
-}, "initPendingBundledTransactionsArchivist");
+};
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
 import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
@@ -743,7 +720,7 @@ import { MemoryArchivist as MemoryArchivist2, MemoryArchivistConfigSchema as Mem
 import { Mutex as Mutex10 } from "async-mutex";
 var mutex9 = new Mutex10();
 var singleton9;
-var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+var initLocalRejectedTransactionsArchivist = async () => {
   return await mutex9.runExclusive(async () => {
     if (singleton9) return singleton9;
     singleton9 = await MemoryArchivist2.create({
@@ -756,7 +733,7 @@ var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () =>
     });
     return singleton9;
   });
-}, "initLocalRejectedTransactionsArchivist");
+};
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
 var mutex10 = new Mutex11();
@@ -769,7 +746,6 @@ async function initRejectedTransactionsArchivist(params) {
     return singleton10;
   });
 }
-__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
 // src/orchestration/archivists/StakeIntentState/archivist.ts
 import { assertEx as assertEx10 } from "@xylabs/assert";
@@ -781,26 +757,26 @@ import { assertEx as assertEx9 } from "@xylabs/assert";
 import { Mutex as Mutex12 } from "async-mutex";
 var mutex11 = new Mutex12();
 var singleton11;
-var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initLocalStakeIntentStateArchivist = async ({ config: config3 }) => {
   return await mutex11.runExclusive(async () => {
     if (singleton11) return singleton11;
     const { root } = config3.storage;
     singleton11 = await getLocalPersistentArchivist("stakeIntent", "state", root);
     return assertEx9(singleton11, () => new Error("Failed to initialize stake intent state archivist"));
   });
-}, "initLocalStakeIntentStateArchivist");
+};
 
 // src/orchestration/archivists/StakeIntentState/archivist.ts
 var mutex12 = new Mutex13();
 var singleton12;
-var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (params) => {
+var initStakeIntentStateArchivist = async (params) => {
   return await mutex12.runExclusive(async () => {
     if (singleton12) return singleton12;
     const local = await startupSpanAsync5("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
     singleton12 = local;
     return assertEx10(singleton12, () => "Error: StakeIntentStateArchivist is undefined");
   });
-}, "initStakeIntentStateArchivist");
+};
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
 import { isDefined as isDefined5 } from "@xylabs/typeof";
@@ -817,34 +793,24 @@ import Path3 from "path";
 
 // src/orchestration/map/driver/lmdb/SynchronousLmdbMap.ts
 import { AbstractCreatable, creatable } from "@xylabs/creatable";
-import { open } from "lmdb";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
+import {
+  open
+} from "lmdb";
 var SynchronousLmdbMap = class extends AbstractCreatable {
-  static {
-    __name(this, "SynchronousLmdbMap");
-  }
   db;
   rootDatabase;
   /**
-  * The path to the LMDB folder where the database is stored.
-  * This is constructed from the location and dbName parameters
-  * allowing for multiple DBs within the root (by specifying a
-  * different storeName).
-  * @returns The folder path for the LMDB database.
-  */
+   * The path to the LMDB folder where the database is stored.
+   * This is constructed from the location and dbName parameters
+   * allowing for multiple DBs within the root (by specifying a
+   * different storeName).
+   * @returns The folder path for the LMDB database.
+   */
   get folderPath() {
     return `${this.params.location}/${this.params.dbName}`;
   }
   all() {
-    return [
-      ...this.db.getRange({})
-    ].map((entry) => entry.value);
+    return [...this.db.getRange({})].map((entry) => entry.value);
   }
   clear() {
     this.db.clearSync();
@@ -864,21 +830,17 @@ var SynchronousLmdbMap = class extends AbstractCreatable {
   }
   async startHandler() {
     await super.startHandler();
-    this.rootDatabase = open({
-      path: this.folderPath
-    });
-    this.db = this.rootDatabase.openDB({
-      name: this.params.storeName
-    });
+    this.rootDatabase = open({ path: this.folderPath });
+    this.db = this.rootDatabase.openDB({ name: this.params.storeName });
   }
 };
-SynchronousLmdbMap = _ts_decorate([
+SynchronousLmdbMap = __decorateClass([
   creatable()
 ], SynchronousLmdbMap);
 
 // src/orchestration/map/localPersistentMap.ts
 var DEFAULT_STORAGE_ROOT2 = Path3.join(process.cwd(), ".store");
-var getLocalPersistentMap = /* @__PURE__ */ __name(async (dbName, storeName, storageRoot, kind = "lmdb") => {
+var getLocalPersistentMap = async (dbName, storeName, storageRoot, kind = "lmdb") => {
   switch (kind) {
     case "lmdb": {
       const root = storageRoot ?? DEFAULT_STORAGE_ROOT2;
@@ -891,19 +853,19 @@ var getLocalPersistentMap = /* @__PURE__ */ __name(async (dbName, storeName, sto
       return store;
     }
   }
-}, "getLocalPersistentMap");
+};
 
 // src/orchestration/map/BalanceSummary/local.ts
 var mutex13 = new Mutex14();
 var singleton13;
-var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(async (params) => {
+var initLocalBalanceSummaryMap = async (params) => {
   return await mutex13.runExclusive(async () => {
     if (isDefined4(singleton13)) return singleton13;
     const { root } = params.config.storage;
     singleton13 = await getLocalPersistentMap("balance", "summary", root);
     return singleton13;
   });
-}, "initLocalBalanceSummaryMap");
+};
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
 var mutex14 = new Mutex15();
@@ -916,14 +878,13 @@ async function initBalanceSummaryMap(params) {
     return singleton14;
   });
 }
-__name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/orchestration/services/implementation/account.ts
 import { isUndefined as isUndefined3 } from "@xylabs/typeof";
 import { HDWallet } from "@xyo-network/wallet";
 import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-protocol-sdk";
 var accountServiceSingleton;
-var initAccount = /* @__PURE__ */ __name(async ({ config: config3, logger }) => {
+var initAccount = async ({ config: config3, logger }) => {
   if (accountServiceSingleton) return accountServiceSingleton;
   let walletPhrase = config3.producer.mnemonic;
   if (isUndefined3(walletPhrase)) {
@@ -940,16 +901,16 @@ ${randomMnemonic}
   const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
   accountServiceSingleton = account;
   return accountServiceSingleton;
-}, "initAccount");
+};
 
 // src/orchestration/services/implementation/balance.ts
 import { BaseAccountBalanceService } from "@xyo-network/chain-services";
 var balanceServiceSingleton;
-var initBalanceService = /* @__PURE__ */ __name(async (params) => {
+var initBalanceService = async (params) => {
   if (balanceServiceSingleton) return balanceServiceSingleton;
   balanceServiceSingleton = await BaseAccountBalanceService.create(params);
   return balanceServiceSingleton;
-}, "initBalanceService");
+};
 
 // src/orchestration/services/implementation/chain/index.ts
 import { MemoryChainService } from "@xyo-network/chain-services";
@@ -973,14 +934,12 @@ import { InfuraProvider } from "ethers/providers";
 import { assertEx as assertEx11 } from "@xylabs/assert";
 import { hexFrom, isHex } from "@xylabs/hex";
 import { isDefined as isDefined6 } from "@xylabs/typeof";
-var canUseChainId = /* @__PURE__ */ __name((config3) => {
+var canUseChainId = (config3) => {
   return isDefined6(config3.evm.chainId);
-}, "canUseChainId");
-var getChainId = /* @__PURE__ */ __name((config3) => {
+};
+var getChainId = (config3) => {
   const chainId = assertEx11(config3.evm.chainId, () => "Missing config.evm.chainId");
-  if (isHex(chainId, {
-    prefix: true
-  })) {
+  if (isHex(chainId, { prefix: true })) {
     const hex = hexFrom(chainId);
     const parsed = Number.parseInt(hex, 16);
     return parsed;
@@ -988,51 +947,44 @@ var getChainId = /* @__PURE__ */ __name((config3) => {
     const parsed = Number.parseInt(chainId, 10);
     return parsed;
   }
-}, "getChainId");
+};
 
 // src/orchestration/services/implementation/evm/initInfuraProvider.ts
 var instance;
-var initInfuraProvider = /* @__PURE__ */ __name((config3) => {
+var initInfuraProvider = (config3) => {
   if (instance) return instance;
   const providerConfig = getInfuraProviderConfig(config3);
   instance = Promise.resolve(new InfuraProvider(...providerConfig));
   return instance;
-}, "initInfuraProvider");
-var canUseInfuraProvider = /* @__PURE__ */ __name((config3) => {
+};
+var canUseInfuraProvider = (config3) => {
   return canUseChainId(config3) && isDefined7(config3.evm?.infura?.projectId) && isDefined7(config3.evm?.infura?.projectSecret);
-}, "canUseInfuraProvider");
-var getInfuraProviderConfig = /* @__PURE__ */ __name((config3) => {
+};
+var getInfuraProviderConfig = (config3) => {
   const projectId = assertEx12(config3.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
   const projectSecret = assertEx12(config3.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
-  return [
-    getChainId(config3),
-    projectId,
-    projectSecret
-  ];
-}, "getInfuraProviderConfig");
+  return [getChainId(config3), projectId, projectSecret];
+};
 
 // src/orchestration/services/implementation/evm/initJsonRpcProvider.ts
 import { assertEx as assertEx13 } from "@xylabs/assert";
 import { isDefined as isDefined8 } from "@xylabs/typeof";
 import { JsonRpcProvider } from "ethers/providers";
-var initJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
+var initJsonRpcProvider = (config3) => {
   const providerConfig = getJsonRpcProviderConfig(config3);
   return Promise.resolve(new JsonRpcProvider(...providerConfig));
-}, "initJsonRpcProvider");
-var canUseJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
+};
+var canUseJsonRpcProvider = (config3) => {
   return canUseChainId(config3) && isDefined8(config3.evm.jsonRpc?.url);
-}, "canUseJsonRpcProvider");
-var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config3) => {
+};
+var getJsonRpcProviderConfig = (config3) => {
   const jsonRpcUrl = assertEx13(config3.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
-  return [
-    jsonRpcUrl,
-    getChainId(config3)
-  ];
-}, "getJsonRpcProviderConfig");
+  return [jsonRpcUrl, getChainId(config3)];
+};
 
 // src/orchestration/services/implementation/evm/initEvmProvider.ts
 var provider;
-var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+var initEvmProvider = async ({ config: config3 }) => {
   if (provider) return provider;
   if (canUseInfuraProvider(config3)) {
     provider = initInfuraProvider(config3);
@@ -1040,26 +992,28 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config3 }) => {
     provider = initJsonRpcProvider(config3);
   }
   return assertEx14(await provider, () => "Error: No provider available");
-}, "initEvmProvider");
-var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config3 }) => {
+};
+var canUseEvmProvider = ({ config: config3 }) => {
   return canUseInfuraProvider(config3) || canUseJsonRpcProvider(config3);
-}, "canUseEvmProvider");
+};
 
 // src/orchestration/services/implementation/chain/evm.ts
 var chainStakeServiceSingleton;
-var canUseEvmContractChainService = /* @__PURE__ */ __name((config3) => {
+var canUseEvmContractChainService = (config3) => {
   const { id } = config3.chain;
-  return isDefined9(id) && id !== ZERO_ADDRESS && canUseEvmProvider({
-    config: config3
-  });
-}, "canUseEvmContractChainService");
-var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config: config3, traceProvider, meterProvider, logger }) => {
+  return isDefined9(id) && id !== ZERO_ADDRESS && canUseEvmProvider({ config: config3 });
+};
+var initEvmContractChainService = async ({
+  account,
+  config: config3,
+  traceProvider,
+  meterProvider,
+  logger
+}) => {
   if (chainStakeServiceSingleton) return chainStakeServiceSingleton;
   const emvStakingContractAddress = assertEx15(config3.chain.id, () => "Error: config.chain.id is required");
   const id = assertEx15(asAddress(emvStakingContractAddress), () => "Error: config.chain.id is not a valid address");
-  const provider2 = assertEx15(await initEvmProvider({
-    config: config3
-  }));
+  const provider2 = assertEx15(await initEvmProvider({ config: config3 }));
   const privateKey = assertEx15(account.private?.hex, () => "Error: Account does not have a private key");
   const runner = new Wallet(privateKey, provider2);
   chainStakeServiceSingleton = EvmChainService.create({
@@ -1070,27 +1024,21 @@ var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, confi
     logger
   });
   return await chainStakeServiceSingleton;
-}, "initEvmContractChainService");
+};
 
 // src/orchestration/services/implementation/chain/index.ts
 var chainStakeServiceSingleton2;
-var initChainService = /* @__PURE__ */ __name(({ account, config: config3 }) => init({
+var initChainService = ({ account, config: config3 }) => init({
   config: config3,
   name: "ChainService",
   account
-}), "initChainService");
-var init = /* @__PURE__ */ __name((params) => {
+});
+var init = (params) => {
   if (chainStakeServiceSingleton2) return chainStakeServiceSingleton2;
   const { config: config3 } = params;
-  chainStakeServiceSingleton2 = canUseEvmContractChainService(config3) ? initEvmContractChainService({
-    ...params,
-    name: "ChainStakeService"
-  }) : MemoryChainService.create({
-    ...params,
-    name: "ChainStakeService"
-  });
+  chainStakeServiceSingleton2 = canUseEvmContractChainService(config3) ? initEvmContractChainService({ ...params, name: "ChainStakeService" }) : MemoryChainService.create({ ...params, name: "ChainStakeService" });
   return chainStakeServiceSingleton2;
-}, "init");
+};
 
 // src/orchestration/services/implementation/head.ts
 import { delay } from "@xylabs/delay";
@@ -1098,88 +1046,90 @@ import { ZERO_ADDRESS as ZERO_ADDRESS2 } from "@xylabs/hex";
 import { createGenesisBlock, findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
 import { flattenHydratedBlock as flattenHydratedBlock2 } from "@xyo-network/xl1-protocol-sdk";
 var headSingleton;
-var createBootstrapHead = /* @__PURE__ */ __name(async (chainSubmissionsArchivistWrite, chainArchivist, account) => {
+var createBootstrapHead = async (chainSubmissionsArchivistWrite, chainArchivist, account) => {
   const block = await createGenesisBlock(account, ZERO_ADDRESS2, 10000000n, account.address);
   const [bw] = block;
   await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock2(block));
   while (true) {
-    const result = await chainArchivist.get([
-      bw._hash
-    ]);
+    const result = await chainArchivist.get([bw._hash]);
     if (result.length > 0) break;
     await delay(1e3);
   }
   return bw;
-}, "createBootstrapHead");
-var initHead = /* @__PURE__ */ __name(async (params) => {
-  const { account, chainArchivist, chainSubmissionsArchivistWrite } = params;
+};
+var initHead = async (params) => {
+  const {
+    account,
+    chainArchivist,
+    chainSubmissionsArchivistWrite
+  } = params;
   if (headSingleton) return headSingleton;
   let head = await findMostRecentBlock2(chainArchivist);
   if (!head) head = await createBootstrapHead(chainSubmissionsArchivistWrite, chainArchivist, account);
   headSingleton = head;
   return headSingleton;
-}, "initHead");
+};
 
 // src/orchestration/services/implementation/iterator.ts
-import { BaseElectionService, ChainBlockNumberIterationService, XyoStakeIntentService } from "@xyo-network/chain-services";
+import {
+  BaseElectionService,
+  ChainBlockNumberIterationService,
+  XyoStakeIntentService
+} from "@xyo-network/chain-services";
 var chainIteratorServiceSingleton;
 var stakeIntentServiceSingleton;
 var electionServiceSingleton;
-var initChainIterator = /* @__PURE__ */ __name((params) => {
+var initChainIterator = (params) => {
   if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
   chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
   return chainIteratorServiceSingleton;
-}, "initChainIterator");
-var initStakeIntentService = /* @__PURE__ */ __name((params) => {
+};
+var initStakeIntentService = (params) => {
   if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
   stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
   return stakeIntentServiceSingleton;
-}, "initStakeIntentService");
-var initElectionService = /* @__PURE__ */ __name((params) => {
+};
+var initElectionService = (params) => {
   if (electionServiceSingleton) return electionServiceSingleton;
   electionServiceSingleton = BaseElectionService.create(params);
   return electionServiceSingleton;
-}, "initElectionService");
+};
 
 // src/orchestration/services/implementation/pendingTransactions.ts
 import { BasePendingTransactionsService } from "@xyo-network/chain-services";
 var serviceSingleton;
-var initPendingTransactions = /* @__PURE__ */ __name(async (params) => {
+var initPendingTransactions = async (params) => {
   if (serviceSingleton) return serviceSingleton;
   serviceSingleton = await BasePendingTransactionsService.create(params);
   return serviceSingleton;
-}, "initPendingTransactions");
+};
 
 // src/orchestration/services/implementation/producer.ts
 import { BaseBlockProducerService as BaseBlockProducerService2 } from "@xyo-network/chain-services";
 var serviceSingleton2;
-var initBlockProducer = /* @__PURE__ */ __name(async (params) => {
+var initBlockProducer = async (params) => {
   if (serviceSingleton2) return serviceSingleton2;
   serviceSingleton2 = await BaseBlockProducerService2.create(params);
   return serviceSingleton2;
-}, "initBlockProducer");
+};
 
 // src/orchestration/services/implementation/reward.ts
 import { assertEx as assertEx16 } from "@xylabs/assert";
 import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-services";
 var rewardServiceSingleton;
-var initBlockRewardService = /* @__PURE__ */ __name((params) => {
+var initBlockRewardService = (params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
   const { config: config3 } = params;
-  rewardServiceSingleton = canUseEvmBlockRewardService({
-    config: config3
-  }) ? initEvmBlockRewardService(params) : initXyoBlockRewardService(params);
+  rewardServiceSingleton = canUseEvmBlockRewardService({ config: config3 }) ? initEvmBlockRewardService(params) : initXyoBlockRewardService(params);
   return rewardServiceSingleton;
-}, "initBlockRewardService");
-var initXyoBlockRewardService = /* @__PURE__ */ __name((params) => {
+};
+var initXyoBlockRewardService = (params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
   rewardServiceSingleton = MemoryBlockRewardService.create(params);
   return rewardServiceSingleton;
-}, "initXyoBlockRewardService");
-var canUseEvmBlockRewardService = /* @__PURE__ */ __name((params) => canUseEvmProvider({
-  config: params.config
-}), "canUseEvmBlockRewardService");
-var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
+};
+var canUseEvmBlockRewardService = (params) => canUseEvmProvider({ config: params.config });
+var initEvmBlockRewardService = async (params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
   const { account: paramsAccount } = params;
   const account = assertEx16(paramsAccount, () => "Error: Account is required");
@@ -1191,21 +1141,18 @@ var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
   };
   rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams);
   return rewardServiceSingleton;
-}, "initEvmBlockRewardService");
+};
 
 // src/orchestration/services/implementation/validator.ts
 var serviceSingleton3;
-var initValidator = /* @__PURE__ */ __name((params) => {
+var initValidator = (params) => {
   if (serviceSingleton3) return serviceSingleton3;
   serviceSingleton3 = initBlockProducer(params);
   return serviceSingleton3;
-}, "initValidator");
+};
 
 // src/orchestration/status/ServiceStatus.ts
 var LoggerStatusReporter = class {
-  static {
-    __name(this, "LoggerStatusReporter");
-  }
   logger;
   statusMap = {};
   constructor(logger) {
@@ -1215,9 +1162,7 @@ var LoggerStatusReporter = class {
     this.statusMap[name] = status;
     const starting = Object.entries(this.statusMap).map(([, value]) => value === "starting" ? 1 : 0).reduce((a, b) => a + b, 0);
     const started = Object.entries(this.statusMap).map(([, value]) => value === "started" ? 1 : 0).reduce((a, b) => a + b, 0);
-    this.logger.info(`${started}/${starting + started} ${name} status: ${status}`, {
-      progress
-    });
+    this.logger.info(`${started}/${starting + started} ${name} status: ${status}`, { progress });
   }
 };
 
@@ -1232,7 +1177,7 @@ var statusPriority = {
   started: 6
 };
 var SENTINEL_STATUS = "starting";
-var reduceToMinimumStatus = /* @__PURE__ */ __name((statuses) => {
+var reduceToMinimumStatus = (statuses) => {
   let minStatus = SENTINEL_STATUS;
   let minPriority = Infinity;
   for (const status of statuses) {
@@ -1243,11 +1188,8 @@ var reduceToMinimumStatus = /* @__PURE__ */ __name((statuses) => {
     }
   }
   return minStatus;
-}, "reduceToMinimumStatus");
+};
 var RuntimeStatusMonitor = class extends LoggerStatusReporter {
-  static {
-    __name(this, "RuntimeStatusMonitor");
-  }
   globalTransitions = [];
   transitions = [];
   getGlobalStatus() {
@@ -1258,19 +1200,13 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
     return this.statusMap[name];
   }
   onGlobalTransition(match, handler) {
-    this.globalTransitions.push({
-      ...match,
-      handler
-    });
+    this.globalTransitions.push({ ...match, handler });
   }
   /**
-  * Register a callback to be called on a specific transition.
-  */
+   * Register a callback to be called on a specific transition.
+   */
   onTransition(match, handler) {
-    this.transitions.push({
-      ...match,
-      handler
-    });
+    this.transitions.push({ ...match, handler });
   }
   report(name, status, progress) {
     const previous = this.statusMap[name];
@@ -1283,7 +1219,12 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
     this.runTransitions(this.globalTransitions, previousGlobal, globalStatus);
   }
   runTransitions(transitions, prev, next, name) {
-    for (const { from, to, name: matchName, handler } of transitions) {
+    for (const {
+      from,
+      to,
+      name: matchName,
+      handler
+    } of transitions) {
       if ((matchName === void 0 || matchName === name) && (from === void 0 || from === prev) && (to === void 0 || to === next)) {
         handler(prev, next);
       }
@@ -1302,28 +1243,24 @@ var telemetryConfig = {
     port: 9464
   }
 };
-var isStartable = /* @__PURE__ */ __name((value) => {
+var isStartable = (value) => {
   return isDefined10(value.start) && typeof value.start === "function";
-}, "isStartable");
-var initServices = /* @__PURE__ */ __name(async (context) => {
+};
+var initServices = async (context) => {
   const { config: config3, logger } = context;
   const statusReporter = new RuntimeStatusMonitor(logger);
-  statusReporter.onGlobalTransition({
-    to: "started"
-  }, () => {
+  statusReporter.onGlobalTransition({ to: "started" }, () => {
     logger.log("All services started.");
   });
-  statusReporter.onGlobalTransition({
-    to: "error"
-  }, () => {
+  statusReporter.onGlobalTransition({ to: "error" }, () => {
     logger.error("Producer encountered an unhandled error!");
     process.exit(1);
   });
-  await startupSpanAsync7("initHealthEndpoints", () => initHealthEndpoints({
-    ...context,
-    statusReporter
-  }));
-  const [{ traceProvider, meterProvider }, account] = await Promise.all([
+  await startupSpanAsync7("initHealthEndpoints", () => initHealthEndpoints({ ...context, statusReporter }));
+  const [
+    { traceProvider, meterProvider },
+    account
+  ] = await Promise.all([
     startupSpanAsync7("initTelemetry", () => initTelemetry(telemetryConfig)),
     startupSpanAsync7("initAccount", () => initAccount(context))
   ]);
@@ -1334,18 +1271,47 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     statusReporter,
     traceProvider
   };
-  const [chainArchivist, [pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite], rejectedTransactionsArchivist, chainSubmissionsArchivistWrite, stakeIntentStateArchivist, chainService, balanceSummaryMap] = await Promise.all([
-    startupSpanAsync7("ChainFinalizedArchivist", () => initChainFinalizedArchivist(initParams)),
-    startupSpanAsync7("PendingBundledTransactionsArchivist", () => initPendingBundledTransactionsArchivist(initParams)),
-    startupSpanAsync7("RejectedTransactionsArchivist", () => initRejectedTransactionsArchivist(initParams)),
-    startupSpanAsync7("ChainSubmissionsArchivist", () => initChainSubmissionsArchivist(initParams)),
-    startupSpanAsync7("StakeIntentStateArchivist", () => initStakeIntentStateArchivist(initParams)),
-    startupSpanAsync7("ChainService", () => initChainService({
-      ...initParams,
-      account,
-      name: "ChainService"
-    })),
-    startupSpanAsync7("BalanceSummaryMap", () => initBalanceSummaryMap(initParams))
+  const [
+    chainArchivist,
+    [pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite],
+    rejectedTransactionsArchivist,
+    chainSubmissionsArchivistWrite,
+    stakeIntentStateArchivist,
+    chainService,
+    balanceSummaryMap
+  ] = await Promise.all([
+    startupSpanAsync7(
+      "ChainFinalizedArchivist",
+      () => initChainFinalizedArchivist(initParams)
+    ),
+    startupSpanAsync7(
+      "PendingBundledTransactionsArchivist",
+      () => initPendingBundledTransactionsArchivist(initParams)
+    ),
+    startupSpanAsync7(
+      "RejectedTransactionsArchivist",
+      () => initRejectedTransactionsArchivist(initParams)
+    ),
+    startupSpanAsync7(
+      "ChainSubmissionsArchivist",
+      () => initChainSubmissionsArchivist(initParams)
+    ),
+    startupSpanAsync7(
+      "StakeIntentStateArchivist",
+      () => initStakeIntentStateArchivist(initParams)
+    ),
+    startupSpanAsync7(
+      "ChainService",
+      () => initChainService({
+        ...initParams,
+        account,
+        name: "ChainService"
+      })
+    ),
+    startupSpanAsync7(
+      "BalanceSummaryMap",
+      () => initBalanceSummaryMap(initParams)
+    )
   ]);
   const chainId = chainService.chainId;
   const chainContractViewer = chainService;
@@ -1357,7 +1323,12 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     chainArchivist,
     chainSubmissionsArchivistWrite
   }));
-  const [pendingTransactionsService, rewardService, chainIterator, balanceService] = await Promise.all([
+  const [
+    pendingTransactionsService,
+    rewardService,
+    chainIterator,
+    balanceService
+  ] = await Promise.all([
     startupSpanAsync7("PendingTransactions", () => initPendingTransactions({
       name: "PendingTransactionsService",
       chainArchivist,
@@ -1366,40 +1337,55 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
       rejectedTransactionsArchivist,
       ...initParams
     })),
-    startupSpanAsync7("RewardService", () => initBlockRewardService({
-      name: "RewardService",
-      account,
-      chainService,
-      ...initParams
-    })),
-    startupSpanAsync7("ChainIterator", () => initChainIterator({
-      name: "ChainIterator",
+    startupSpanAsync7(
+      "RewardService",
+      () => initBlockRewardService({
+        name: "RewardService",
+        account,
+        chainService,
+        ...initParams
+      })
+    ),
+    startupSpanAsync7(
+      "ChainIterator",
+      () => initChainIterator({
+        name: "ChainIterator",
+        chainArchivist,
+        head,
+        ...initParams
+      })
+    ),
+    startupSpanAsync7(
+      "BalanceService",
+      () => initBalanceService({
+        name: "BalanceService",
+        chainArchivist,
+        summaryRepository: balanceSummaryRepositoryFromMap(balanceSummaryMap),
+        ...initParams
+      })
+    )
+  ]);
+  const stakeIntentService = await startupSpanAsync7(
+    "StakeIntentService",
+    () => initStakeIntentService({
+      name: "StakeIntentService",
       chainArchivist,
-      head,
+      chainIterator,
+      chainStakeViewer,
+      stakeIntentStateArchivist,
       ...initParams
-    })),
-    startupSpanAsync7("BalanceService", () => initBalanceService({
-      name: "BalanceService",
-      chainArchivist,
-      summaryRepository: balanceSummaryRepositoryFromMap(balanceSummaryMap),
+    })
+  );
+  const electionService = await startupSpanAsync7(
+    "ElectionService",
+    () => initElectionService({
+      name: "ElectionService",
+      chainIterator,
+      chainStakeViewer,
+      stakeIntentService,
       ...initParams
-    }))
-  ]);
-  const stakeIntentService = await startupSpanAsync7("StakeIntentService", () => initStakeIntentService({
-    name: "StakeIntentService",
-    chainArchivist,
-    chainIterator,
-    chainStakeViewer,
-    stakeIntentStateArchivist,
-    ...initParams
-  }));
-  const electionService = await startupSpanAsync7("ElectionService", () => initElectionService({
-    name: "ElectionService",
-    chainIterator,
-    chainStakeViewer,
-    stakeIntentService,
-    ...initParams
-  }));
+    })
+  );
   const validatorParams = {
     name: "Validator",
     account,
@@ -1442,13 +1428,10 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     stakeIntentService
   };
   logger?.log("All services created. Starting...");
-  const startableServices = [
-    balanceSummaryMap,
-    ...Object.values(result)
-  ].filter(isStartable);
+  const startableServices = [balanceSummaryMap, ...Object.values(result)].filter(isStartable);
   await Promise.all(startableServices.map((service) => service.start()));
   return result;
-}, "initServices");
+};
 
 // src/runCLI.ts
 import { deepMerge } from "@xylabs/object";
@@ -1463,31 +1446,27 @@ import { getServer } from "@xyo-network/chain-api";
 function runApi(context) {
   void getServer(context);
 }
-__name(runApi, "runApi");
 
 // src/commands/producer/runProducer.ts
-var runProducer = /* @__PURE__ */ __name(async (context) => {
-  const { config: config3, logger, orchestrator } = context;
+var runProducer = async (context) => {
+  const {
+    config: config3,
+    logger,
+    orchestrator
+  } = context;
   logger?.log("Services: Initializing...");
   const services = await initServices(context);
   logger?.log("Services: Initialized");
-  const params = {
-    ...services,
-    config: config3
-  };
+  const params = { ...services, config: config3 };
   const chainHeadUpdate = await ChainHeadUpdateActor.create(params);
   const balances = await BalanceActor.create(params);
   const producer = await ProducerActor.create(params);
-  const actors = [
-    chainHeadUpdate,
-    balances,
-    producer
-  ];
+  const actors = [chainHeadUpdate, balances, producer];
   for (const actor of actors) {
     await orchestrator.registerActor(actor);
   }
   await orchestrator.start();
-}, "runProducer");
+};
 
 // src/images.ts
 var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;118;111;144m_\x1B[0m
@@ -1511,9 +1490,13 @@ var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\
 
 // src/initLogger.ts
 import { Base as Base2 } from "@xylabs/base";
-import { ConsoleLogger, LogLevel, SilentLogger } from "@xylabs/logger";
+import {
+  ConsoleLogger,
+  LogLevel,
+  SilentLogger
+} from "@xylabs/logger";
 import { isDefined as isDefined11 } from "@xylabs/typeof";
-var initLogger = /* @__PURE__ */ __name((config3) => {
+var initLogger = (config3) => {
   let logger;
   if (config3.silent) {
     logger = new SilentLogger();
@@ -1527,18 +1510,22 @@ var initLogger = /* @__PURE__ */ __name((config3) => {
   }
   Base2.defaultLogger = logger;
   return logger;
-}, "initLogger");
+};
 
 // src/optionsFromZodSchema.ts
-import { ZodBoolean, ZodDefault, ZodEnum, ZodNumber, ZodObject, ZodOptional } from "zod";
-var collectOptions = /* @__PURE__ */ __name((zodType, path = [], out = {}) => {
+import {
+  ZodBoolean,
+  ZodDefault,
+  ZodEnum,
+  ZodNumber,
+  ZodObject,
+  ZodOptional
+} from "zod";
+var collectOptions = (zodType, path = [], out = {}) => {
   if (zodType instanceof ZodObject) {
     const shape = zodType.shape;
     for (const [k, v] of Object.entries(shape)) {
-      collectOptions(v, [
-        ...path,
-        k
-      ], out);
+      collectOptions(v, [...path, k], out);
     }
     return out;
   }
@@ -1546,10 +1533,7 @@ var collectOptions = /* @__PURE__ */ __name((zodType, path = [], out = {}) => {
   if (def?.innerType instanceof ZodObject) {
     const shape = def.innerType.shape;
     for (const [k, v] of Object.entries(shape)) {
-      collectOptions(v, [
-        ...path,
-        k
-      ], out);
+      collectOptions(v, [...path, k], out);
     }
     return out;
   }
@@ -1567,24 +1551,35 @@ var collectOptions = /* @__PURE__ */ __name((zodType, path = [], out = {}) => {
   const key = path.join(".");
   out[key] = options;
   return out;
-}, "collectOptions");
-var optionsFromZodSchema = /* @__PURE__ */ __name((schema) => {
+};
+var optionsFromZodSchema = (schema) => {
   const opts = {};
   for (const [rootKey, zodType] of Object.entries(schema)) {
-    collectOptions(zodType, [
-      rootKey
-    ], opts);
+    collectOptions(zodType, [rootKey], opts);
   }
   return opts;
-}, "optionsFromZodSchema");
+};
 
 // src/tryParseConfig.ts
 import { isDefined as isDefined12, isNull } from "@xylabs/typeof";
 import { cosmiconfigSync } from "cosmiconfig";
 var configName = "xyo";
 var configSection = "xl1";
-var tryParseConfig = /* @__PURE__ */ __name(() => {
-  const explorer = cosmiconfigSync(configName);
+var tryParseConfig = () => {
+  const explorer = cosmiconfigSync(
+    configName
+    /* {
+      searchPlaces: [
+        'package.json', // Looks under `xyo` key in package.json
+        '.xyorc.json', // Supports common dotfile format
+        'xyo.config.json', // Supports custom-named config file
+      ],
+      loaders: {
+        '.json': defaultLoaders['.json'],
+        'noExt': defaultLoaders['.json'],
+      },
+    }, */
+  );
   const result = explorer.search();
   if (!isNull(result)) {
     const section = result?.config?.[configSection];
@@ -1593,13 +1588,13 @@ var tryParseConfig = /* @__PURE__ */ __name(() => {
     }
   }
   return {};
-}, "tryParseConfig");
+};
 
 // src/waitForHostPort.ts
 import net from "net";
-var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
+var waitForHostPort = (host, port) => {
   return new Promise((resolve) => {
-    const tryConnect = /* @__PURE__ */ __name(() => {
+    const tryConnect = () => {
       const socket = new net.Socket();
       socket.setTimeout(1e3).once("error", () => {
         socket.destroy();
@@ -1611,15 +1606,15 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
         socket.end();
         resolve();
       });
-    }, "tryConnect");
+    };
     tryConnect();
   });
-}, "waitForHostPort");
+};
 
 // src/runCLI.ts
 var config;
-var version = isDefined13("1.8.3") ? "1.8.3" : "unknown";
-var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
+var version = isDefined13("1.9.0") ? "1.9.0" : "unknown";
+var getContextFromConfig = (config3) => {
   const logger = initLogger(config3);
   const orchestrator = new Orchestrator(logger);
   process.on("SIGINT", () => {
@@ -1635,11 +1630,8 @@ var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
       }
     })();
   });
-  return {
-    logger,
-    orchestrator
-  };
-}, "getContextFromConfig");
+  return { logger, orchestrator };
+};
 async function runCLI() {
   const y = yargs(hideBin(process.argv));
   const argv = y.usage(`
@@ -1650,7 +1642,9 @@ Run various components of the XL1 ecosystem.
 Usage:
 $0 <command> [options]`).parserConfiguration({
     "dot-notation": true,
+    // foo.bar → { foo: { bar } }
     "populate--": true
+    // Populate -- with all options so we can detected user-supplied vs defaults
   }).env("XL1").scriptName("xl1").version(version).middleware((argv2) => {
     try {
       const parsedConfigFile = tryParseConfig();
@@ -1669,45 +1663,30 @@ $0 <command> [options]`).parserConfiguration({
     return yargs2.command("$0", "Run a XL1 API Node", () => {
     }, () => {
       const context = getContextFromConfig(config);
-      runApi({
-        ...context,
-        config
-      });
+      runApi({ ...context, config });
     });
   }).command("producer", "Run a XL1 Producer Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Producer Node", () => {
     }, async () => {
       const context = getContextFromConfig(config);
-      await runProducer({
-        ...context,
-        config
-      });
+      await runProducer({ ...context, config });
     });
   }).command("$0", "Run a full XL1 Node", () => {
   }, async () => {
     const context = getContextFromConfig(config);
-    runApi({
-      ...context,
-      config
-    });
+    runApi({ ...context, config });
     await waitForHostPort("localhost", config.api.port);
-    await runProducer({
-      ...context,
-      config
-    });
+    await runProducer({ ...context, config });
   }).help().alias("help", "h").argv;
   await argv;
 }
-__name(runCLI, "runCLI");
 
 // src/start.ts
 import { config as config2 } from "dotenv";
-var start = /* @__PURE__ */ __name(async () => {
-  config2({
-    quiet: true
-  });
+var start = async () => {
+  config2({ quiet: true });
   await runCLI();
-}, "start");
+};
 export {
   Actor,
   BalanceActor,