@xyo-network/xl1-cli-lib 1.12.0 → 1.12.2

package/dist/node/index.mjs

@@ -1,13 +1,5 @@
 var __defProp = Object.defineProperty;
-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;
-};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/orchestration/actor/implementation/BalanceActor.ts
 import { assertEx } from "@xylabs/assert";
@@ -20,13 +12,19 @@ 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;
   }
@@ -43,29 +41,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 = async () => {
+    const schedulePeriodicRun = /* @__PURE__ */ __name(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));
       }
-    };
-    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.`
-    );
+    }, "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.`);
   }
   span(name, fn) {
     return span(`${this.name}:${name}`, fn, this.tracer);
@@ -74,17 +72,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;
@@ -99,6 +97,9 @@ var Actor = class extends Base {
 
 // src/orchestration/actor/model/Orchestrator.ts
 var Orchestrator = class {
+  static {
+    __name(this, "Orchestrator");
+  }
   actors = [];
   keepAliveHandle = null;
   logger;
@@ -107,9 +108,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();
@@ -117,8 +118,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) {
@@ -134,8 +135,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) {
@@ -154,6 +155,9 @@ 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);
@@ -189,9 +193,12 @@ var BalanceActor = class _BalanceActor extends Actor {
 import { filterAs } from "@xylabs/array";
 import { assertEx as assertEx2 } from "@xylabs/assert";
 import { toHex } from "@xylabs/hex";
-import { findMostRecentBlock, sortBlocks } from "@xyo-network/chain-protocol";
+import { findMostRecentBlock, sortBlocks } from "@xyo-network/chain-sdk";
 import { asBlockBoundWitness } from "@xyo-network/xl1-protocol";
 var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
+  static {
+    __name(this, "ChainHeadUpdateActor");
+  }
   constructor(params) {
     super("ChainHeadUpdate", "ChainHeadUpdate", params);
   }
@@ -237,18 +244,16 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
 import { assertEx as assertEx3 } from "@xylabs/assert";
 import { toHex as toHex2 } from "@xylabs/hex";
 import { isDefined, isUndefined } from "@xylabs/typeof";
-import { createDeclarationIntent } from "@xyo-network/chain-protocol";
-import { BaseBlockProducerService } from "@xyo-network/chain-services";
+import { BaseBlockProducerService, createDeclarationIntent } from "@xyo-network/chain-sdk";
 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) {
@@ -318,24 +323,15 @@ 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;
         });
@@ -345,30 +341,37 @@ 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.`);
@@ -395,6 +398,9 @@ 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) {
@@ -464,16 +470,24 @@ var ValidatorActor = class _ValidatorActor extends Actor {
 // src/orchestration/health/initHealthEndpoints.ts
 import http from "http";
 import { isDefined as isDefined3 } from "@xylabs/typeof";
-var sendStatus = (res, status, errorCode) => {
+var sendStatus = /* @__PURE__ */ __name((res, status, errorCode) => {
   const statusCode = status === "started" ? 200 : errorCode;
-  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) => {
+  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) => {
   const server = http.createServer((req, res) => {
     const url = req.url ?? "";
     const status = statusMonitor.getGlobalStatus();
@@ -502,29 +516,21 @@ var createHealthServer = (port, statusMonitor, logger) => {
     logger.log(" - /readyz");
   });
   return server;
-};
-var initHealthEndpoints = (params) => {
-  const {
-    config: config3,
-    logger,
-    statusReporter
-  } = params;
+}, "createHealthServer");
+var initHealthEndpoints = /* @__PURE__ */ __name((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";
 import { asAddress as asAddress2 } from "@xylabs/hex";
 import { isDefined as isDefined10 } from "@xylabs/typeof";
-import { balanceSummaryRepositoryFromMap } from "@xyo-network/chain-modules";
-import { initTelemetry } from "@xyo-network/chain-telemetry";
-import { startupSpanAsync as startupSpanAsync7 } from "@xyo-network/chain-utils";
-import { validateHydratedBlockState } from "@xyo-network/chain-validation";
+import { balanceSummaryRepositoryFromMap, initTelemetry, startupSpanAsync as startupSpanAsync7, validateHydratedBlockState } from "@xyo-network/chain-sdk";
 
 // src/orchestration/archivists/ChainFinalized/archivist.ts
-import { initArchivistSync } from "@xyo-network/chain-orchestration";
-import { startupSpanAsync } from "@xyo-network/chain-utils";
+import { initArchivistSync, startupSpanAsync } from "@xyo-network/chain-sdk";
 import { Mutex as Mutex4 } from "async-mutex";
 
 // src/orchestration/archivists/ChainFinalized/local.ts
@@ -537,13 +543,13 @@ import { LmdbArchivist, LmdbArchivistConfigSchema } from "@xyo-network/archivist
 
 // src/orchestration/store/getStoreDirectory.ts
 import Path from "path";
-var getStoreDirectory = (name, storageRoot, kind) => {
+var getStoreDirectory = /* @__PURE__ */ __name((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 = (dbName, storeName, storageRoot, kind = "lmdb") => {
+var getLocalPersistentArchivist = /* @__PURE__ */ __name((dbName, storeName, storageRoot, kind = "lmdb") => {
   switch (kind) {
     case "lmdb": {
       const root = storageRoot ?? DEFAULT_STORAGE_ROOT;
@@ -559,99 +565,104 @@ var getLocalPersistentArchivist = (dbName, storeName, storageRoot, kind = "lmdb"
       });
     }
   }
-};
+}, "getLocalPersistentArchivist");
 
 // src/orchestration/archivists/ChainFinalized/local.ts
 var mutex = new Mutex2();
 var singleton;
-var initLocalChainFinalizedArchivist = async ({ config: config3 }) => {
+var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(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";
-import { initBridge, initBridgedArchivistModule } from "@xyo-network/chain-orchestration";
+import { initBridge, initBridgedArchivistModule } from "@xyo-network/chain-sdk";
 import { getUrl } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
 var mutex2 = new Mutex3();
 var singleton2;
-var initRemoteChainFinalizedArchivist = async ({ config: config3 }) => {
+var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(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";
-import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
+import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-sdk";
 import { Mutex as Mutex6 } from "async-mutex";
 
 // src/orchestration/archivists/ChainSubmissions/remote.ts
 import { assertEx as assertEx6 } from "@xylabs/assert";
-import { initBridge as initBridge2, initBridgedArchivistModule as initBridgedArchivistModule2 } from "@xyo-network/chain-orchestration";
+import { initBridge as initBridge2, initBridgedArchivistModule as initBridgedArchivistModule2 } from "@xyo-network/chain-sdk";
 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 = async ({ config: config3 }) => {
+var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(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 = async (params) => {
+var initChainSubmissionsArchivist = /* @__PURE__ */ __name(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";
-import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
+import { initArchivistSync as initArchivistSync2, startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-sdk";
 import { Mutex as Mutex9 } from "async-mutex";
 
 // src/orchestration/archivists/PendingTransactions/local.ts
@@ -659,7 +670,7 @@ import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archi
 import { Mutex as Mutex7 } from "async-mutex";
 var mutex6 = new Mutex7();
 var singleton6;
-var initLocalPendingTransactionsArchivist = async () => {
+var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex6.runExclusive(async () => {
     if (singleton6) return singleton6;
     singleton6 = await MemoryArchivist.create({
@@ -672,47 +683,53 @@ var initLocalPendingTransactionsArchivist = async () => {
     });
     return singleton6;
   });
-};
+}, "initLocalPendingTransactionsArchivist");
 
 // src/orchestration/archivists/PendingTransactions/remote.ts
 import { assertEx as assertEx8 } from "@xylabs/assert";
-import { initBridge as initBridge3, initBridgedArchivistModule as initBridgedArchivistModule3 } from "@xyo-network/chain-orchestration";
+import { initBridge as initBridge3, initBridgedArchivistModule as initBridgedArchivistModule3 } from "@xyo-network/chain-sdk";
 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 = async ({ config: config3 }) => {
+var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(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 = async (params) => {
+var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(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";
+import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-sdk";
 import { Mutex as Mutex11 } from "async-mutex";
 
 // src/orchestration/archivists/RejectedTransactions/local.ts
@@ -720,7 +737,7 @@ import { MemoryArchivist as MemoryArchivist2, MemoryArchivistConfigSchema as Mem
 import { Mutex as Mutex10 } from "async-mutex";
 var mutex9 = new Mutex10();
 var singleton9;
-var initLocalRejectedTransactionsArchivist = async () => {
+var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex9.runExclusive(async () => {
     if (singleton9) return singleton9;
     singleton9 = await MemoryArchivist2.create({
@@ -733,7 +750,7 @@ var initLocalRejectedTransactionsArchivist = async () => {
     });
     return singleton9;
   });
-};
+}, "initLocalRejectedTransactionsArchivist");
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
 var mutex10 = new Mutex11();
@@ -746,10 +763,11 @@ async function initRejectedTransactionsArchivist(params) {
     return singleton10;
   });
 }
+__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
 // src/orchestration/archivists/StakeIntentState/archivist.ts
 import { assertEx as assertEx10 } from "@xylabs/assert";
-import { startupSpanAsync as startupSpanAsync5 } from "@xyo-network/chain-utils";
+import { startupSpanAsync as startupSpanAsync5 } from "@xyo-network/chain-sdk";
 import { Mutex as Mutex13 } from "async-mutex";
 
 // src/orchestration/archivists/StakeIntentState/local.ts
@@ -757,30 +775,30 @@ import { assertEx as assertEx9 } from "@xylabs/assert";
 import { Mutex as Mutex12 } from "async-mutex";
 var mutex11 = new Mutex12();
 var singleton11;
-var initLocalStakeIntentStateArchivist = async ({ config: config3 }) => {
+var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(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 = async (params) => {
+var initStakeIntentStateArchivist = /* @__PURE__ */ __name(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";
-import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-utils";
+import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-sdk";
 import { Mutex as Mutex15 } from "async-mutex";
 
 // src/orchestration/map/BalanceSummary/local.ts
@@ -793,24 +811,34 @@ import Path3 from "path";
 
 // src/orchestration/map/driver/lmdb/SynchronousLmdbMap.ts
 import { AbstractCreatable, creatable } from "@xylabs/creatable";
-import {
-  open
-} from "lmdb";
+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");
 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();
@@ -830,17 +858,21 @@ 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 = __decorateClass([
+SynchronousLmdbMap = _ts_decorate([
   creatable()
 ], SynchronousLmdbMap);
 
 // src/orchestration/map/localPersistentMap.ts
 var DEFAULT_STORAGE_ROOT2 = Path3.join(process.cwd(), ".store");
-var getLocalPersistentMap = async (dbName, storeName, storageRoot, kind = "lmdb") => {
+var getLocalPersistentMap = /* @__PURE__ */ __name(async (dbName, storeName, storageRoot, kind = "lmdb") => {
   switch (kind) {
     case "lmdb": {
       const root = storageRoot ?? DEFAULT_STORAGE_ROOT2;
@@ -853,19 +885,19 @@ var getLocalPersistentMap = async (dbName, storeName, storageRoot, kind = "lmdb"
       return store;
     }
   }
-};
+}, "getLocalPersistentMap");
 
 // src/orchestration/map/BalanceSummary/local.ts
 var mutex13 = new Mutex14();
 var singleton13;
-var initLocalBalanceSummaryMap = async (params) => {
+var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(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();
@@ -878,13 +910,14 @@ 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 = async ({ config: config3, logger }) => {
+var initAccount = /* @__PURE__ */ __name(async ({ config: config3, logger }) => {
   if (accountServiceSingleton) return accountServiceSingleton;
   let walletPhrase = config3.producer.mnemonic;
   if (isUndefined3(walletPhrase)) {
@@ -901,25 +934,25 @@ ${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";
+import { BaseAccountBalanceService } from "@xyo-network/chain-sdk";
 var balanceServiceSingleton;
-var initBalanceService = async (params) => {
+var initBalanceService = /* @__PURE__ */ __name(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";
+import { MemoryChainService } from "@xyo-network/chain-sdk";
 
 // src/orchestration/services/implementation/chain/evm.ts
 import { assertEx as assertEx15 } from "@xylabs/assert";
 import { asAddress, ZERO_ADDRESS } from "@xylabs/hex";
 import { isDefined as isDefined9 } from "@xylabs/typeof";
-import { EvmChainService } from "@xyo-network/chain-services";
+import { EvmChainService } from "@xyo-network/chain-sdk";
 import { Wallet } from "ethers/wallet";
 
 // src/orchestration/services/implementation/evm/initEvmProvider.ts
@@ -934,12 +967,14 @@ 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 = (config3) => {
+var canUseChainId = /* @__PURE__ */ __name((config3) => {
   return isDefined6(config3.evm.chainId);
-};
-var getChainId = (config3) => {
+}, "canUseChainId");
+var getChainId = /* @__PURE__ */ __name((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;
@@ -947,44 +982,51 @@ var getChainId = (config3) => {
     const parsed = Number.parseInt(chainId, 10);
     return parsed;
   }
-};
+}, "getChainId");
 
 // src/orchestration/services/implementation/evm/initInfuraProvider.ts
 var instance;
-var initInfuraProvider = (config3) => {
+var initInfuraProvider = /* @__PURE__ */ __name((config3) => {
   if (instance) return instance;
   const providerConfig = getInfuraProviderConfig(config3);
   instance = Promise.resolve(new InfuraProvider(...providerConfig));
   return instance;
-};
-var canUseInfuraProvider = (config3) => {
+}, "initInfuraProvider");
+var canUseInfuraProvider = /* @__PURE__ */ __name((config3) => {
   return canUseChainId(config3) && isDefined7(config3.evm?.infura?.projectId) && isDefined7(config3.evm?.infura?.projectSecret);
-};
-var getInfuraProviderConfig = (config3) => {
+}, "canUseInfuraProvider");
+var getInfuraProviderConfig = /* @__PURE__ */ __name((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];
-};
+  return [
+    getChainId(config3),
+    projectId,
+    projectSecret
+  ];
+}, "getInfuraProviderConfig");
 
 // 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 = (config3) => {
+var initJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
   const providerConfig = getJsonRpcProviderConfig(config3);
   return Promise.resolve(new JsonRpcProvider(...providerConfig));
-};
-var canUseJsonRpcProvider = (config3) => {
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
   return canUseChainId(config3) && isDefined8(config3.evm.jsonRpc?.url);
-};
-var getJsonRpcProviderConfig = (config3) => {
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config3) => {
   const jsonRpcUrl = assertEx13(config3.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
-  return [jsonRpcUrl, getChainId(config3)];
-};
+  return [
+    jsonRpcUrl,
+    getChainId(config3)
+  ];
+}, "getJsonRpcProviderConfig");
 
 // src/orchestration/services/implementation/evm/initEvmProvider.ts
 var provider;
-var initEvmProvider = async ({ config: config3 }) => {
+var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config3 }) => {
   if (provider) return provider;
   if (canUseInfuraProvider(config3)) {
     provider = initInfuraProvider(config3);
@@ -992,28 +1034,26 @@ var initEvmProvider = async ({ config: config3 }) => {
     provider = initJsonRpcProvider(config3);
   }
   return assertEx14(await provider, () => "Error: No provider available");
-};
-var canUseEvmProvider = ({ config: config3 }) => {
+}, "initEvmProvider");
+var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config3 }) => {
   return canUseInfuraProvider(config3) || canUseJsonRpcProvider(config3);
-};
+}, "canUseEvmProvider");
 
 // src/orchestration/services/implementation/chain/evm.ts
 var chainStakeServiceSingleton;
-var canUseEvmContractChainService = (config3) => {
+var canUseEvmContractChainService = /* @__PURE__ */ __name((config3) => {
   const { id } = config3.chain;
-  return isDefined9(id) && id !== ZERO_ADDRESS && canUseEvmProvider({ config: config3 });
-};
-var initEvmContractChainService = async ({
-  account,
-  config: config3,
-  traceProvider,
-  meterProvider,
-  logger
-}) => {
+  return isDefined9(id) && id !== ZERO_ADDRESS && canUseEvmProvider({
+    config: config3
+  });
+}, "canUseEvmContractChainService");
+var initEvmContractChainService = /* @__PURE__ */ __name(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({
@@ -1024,112 +1064,116 @@ var initEvmContractChainService = async ({
     logger
   });
   return await chainStakeServiceSingleton;
-};
+}, "initEvmContractChainService");
 
 // src/orchestration/services/implementation/chain/index.ts
 var chainStakeServiceSingleton2;
-var initChainService = ({ account, config: config3 }) => init({
+var initChainService = /* @__PURE__ */ __name(({ account, config: config3 }) => init({
   config: config3,
   name: "ChainService",
   account
-});
-var init = (params) => {
+}), "initChainService");
+var init = /* @__PURE__ */ __name((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";
 import { ZERO_ADDRESS as ZERO_ADDRESS2 } from "@xylabs/hex";
-import { createGenesisBlock, findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
+import { createGenesisBlock, findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-sdk";
 import { flattenHydratedBlock as flattenHydratedBlock2 } from "@xyo-network/xl1-protocol-sdk";
 var headSingleton;
-var createBootstrapHead = async (chainSubmissionsArchivistWrite, chainArchivist, account) => {
+var createBootstrapHead = /* @__PURE__ */ __name(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;
-};
-var initHead = async (params) => {
-  const {
-    account,
-    chainArchivist,
-    chainSubmissionsArchivistWrite
-  } = params;
+}, "createBootstrapHead");
+var initHead = /* @__PURE__ */ __name(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-sdk";
 var chainIteratorServiceSingleton;
 var stakeIntentServiceSingleton;
 var electionServiceSingleton;
-var initChainIterator = (params) => {
+var initChainIterator = /* @__PURE__ */ __name((params) => {
   if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
   chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
   return chainIteratorServiceSingleton;
-};
-var initStakeIntentService = (params) => {
+}, "initChainIterator");
+var initStakeIntentService = /* @__PURE__ */ __name((params) => {
   if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
   stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
   return stakeIntentServiceSingleton;
-};
-var initElectionService = (params) => {
+}, "initStakeIntentService");
+var initElectionService = /* @__PURE__ */ __name((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";
+import { BasePendingTransactionsService } from "@xyo-network/chain-sdk";
 var serviceSingleton;
-var initPendingTransactions = async (params) => {
+var initPendingTransactions = /* @__PURE__ */ __name(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";
+import { BaseBlockProducerService as BaseBlockProducerService2 } from "@xyo-network/chain-sdk";
 var serviceSingleton2;
-var initBlockProducer = async (params) => {
+var initBlockProducer = /* @__PURE__ */ __name(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";
+import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-sdk";
 var rewardServiceSingleton;
-var initBlockRewardService = (params) => {
+var initBlockRewardService = /* @__PURE__ */ __name((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;
-};
-var initXyoBlockRewardService = (params) => {
+}, "initBlockRewardService");
+var initXyoBlockRewardService = /* @__PURE__ */ __name((params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
   rewardServiceSingleton = MemoryBlockRewardService.create(params);
   return rewardServiceSingleton;
-};
-var canUseEvmBlockRewardService = (params) => canUseEvmProvider({ config: params.config });
-var initEvmBlockRewardService = async (params) => {
+}, "initXyoBlockRewardService");
+var canUseEvmBlockRewardService = /* @__PURE__ */ __name((params) => canUseEvmProvider({
+  config: params.config
+}), "canUseEvmBlockRewardService");
+var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
   const { account: paramsAccount } = params;
   const account = assertEx16(paramsAccount, () => "Error: Account is required");
@@ -1141,18 +1185,21 @@ var initEvmBlockRewardService = async (params) => {
   };
   rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams);
   return rewardServiceSingleton;
-};
+}, "initEvmBlockRewardService");
 
 // src/orchestration/services/implementation/validator.ts
 var serviceSingleton3;
-var initValidator = (params) => {
+var initValidator = /* @__PURE__ */ __name((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) {
@@ -1162,7 +1209,9 @@ 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
+    });
   }
 };
 
@@ -1177,7 +1226,7 @@ var statusPriority = {
   started: 6
 };
 var SENTINEL_STATUS = "starting";
-var reduceToMinimumStatus = (statuses) => {
+var reduceToMinimumStatus = /* @__PURE__ */ __name((statuses) => {
   let minStatus = SENTINEL_STATUS;
   let minPriority = Infinity;
   for (const status of statuses) {
@@ -1188,8 +1237,11 @@ var reduceToMinimumStatus = (statuses) => {
     }
   }
   return minStatus;
-};
+}, "reduceToMinimumStatus");
 var RuntimeStatusMonitor = class extends LoggerStatusReporter {
+  static {
+    __name(this, "RuntimeStatusMonitor");
+  }
   globalTransitions = [];
   transitions = [];
   getGlobalStatus() {
@@ -1200,13 +1252,19 @@ 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];
@@ -1219,12 +1277,7 @@ 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);
       }
@@ -1243,24 +1296,28 @@ var telemetryConfig = {
     port: 9464
   }
 };
-var isStartable = (value) => {
+var isStartable = /* @__PURE__ */ __name((value) => {
   return isDefined10(value.start) && typeof value.start === "function";
-};
-var initServices = async (context) => {
+}, "isStartable");
+var initServices = /* @__PURE__ */ __name(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))
   ]);
@@ -1271,47 +1328,18 @@ var initServices = 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;
@@ -1323,12 +1351,7 @@ var initServices = 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,
@@ -1337,55 +1360,40 @@ var initServices = async (context) => {
       rejectedTransactionsArchivist,
       ...initParams
     })),
-    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",
+    startupSpanAsync7("RewardService", () => initBlockRewardService({
+      name: "RewardService",
+      account,
+      chainService,
+      ...initParams
+    })),
+    startupSpanAsync7("ChainIterator", () => initChainIterator({
+      name: "ChainIterator",
       chainArchivist,
-      chainIterator,
-      chainStakeViewer,
-      stakeIntentStateArchivist,
+      head,
       ...initParams
-    })
-  );
-  const electionService = await startupSpanAsync7(
-    "ElectionService",
-    () => initElectionService({
-      name: "ElectionService",
-      chainIterator,
-      chainStakeViewer,
-      stakeIntentService,
+    })),
+    startupSpanAsync7("BalanceService", () => initBalanceService({
+      name: "BalanceService",
+      chainArchivist,
+      summaryRepository: balanceSummaryRepositoryFromMap(balanceSummaryMap),
       ...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,
@@ -1428,10 +1436,13 @@ var initServices = 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";
@@ -1446,27 +1457,31 @@ import { getServer } from "@xyo-network/chain-api";
 function runApi(context) {
   void getServer(context);
 }
+__name(runApi, "runApi");
 
 // src/commands/producer/runProducer.ts
-var runProducer = async (context) => {
-  const {
-    config: config3,
-    logger,
-    orchestrator
-  } = context;
+var runProducer = /* @__PURE__ */ __name(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
@@ -1490,13 +1505,9 @@ 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 = (config3) => {
+var initLogger = /* @__PURE__ */ __name((config3) => {
   let logger;
   if (config3.silent) {
     logger = new SilentLogger();
@@ -1510,15 +1521,15 @@ var initLogger = (config3) => {
   }
   Base2.defaultLogger = logger;
   return logger;
-};
+}, "initLogger");
 
 // src/optionsFromGlobalZodRegistry.ts
 import { isUsageMeta } from "@xyo-network/xl1-protocol-sdk";
 import { globalRegistry } from "zod";
-var usageMetaToOptions = (meta) => {
+var usageMetaToOptions = /* @__PURE__ */ __name((meta) => {
   return meta;
-};
-var optionsFromGlobalZodRegistry = () => {
+}, "usageMetaToOptions");
+var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
   const opts = {};
   for (const schema of globalRegistry._map.values()) {
     if (isUsageMeta(schema)) {
@@ -1527,28 +1538,15 @@ var optionsFromGlobalZodRegistry = () => {
     }
   }
   return opts;
-};
+}, "optionsFromGlobalZodRegistry");
 
 // src/tryParseConfig.ts
 import { isDefined as isDefined12, isNull } from "@xylabs/typeof";
 import { cosmiconfigSync } from "cosmiconfig";
 var configName = "xyo";
 var configSection = "xl1";
-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'],
-      },
-    }, */
-  );
+var tryParseConfig = /* @__PURE__ */ __name(() => {
+  const explorer = cosmiconfigSync(configName);
   const result = explorer.search();
   if (!isNull(result)) {
     const section = result?.config?.[configSection];
@@ -1557,13 +1555,13 @@ var tryParseConfig = () => {
     }
   }
   return {};
-};
+}, "tryParseConfig");
 
 // src/waitForHostPort.ts
 import net from "net";
-var waitForHostPort = (host, port) => {
+var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
   return new Promise((resolve) => {
-    const tryConnect = () => {
+    const tryConnect = /* @__PURE__ */ __name(() => {
       const socket = new net.Socket();
       socket.setTimeout(1e3).once("error", () => {
         socket.destroy();
@@ -1575,15 +1573,15 @@ var waitForHostPort = (host, port) => {
         socket.end();
         resolve();
       });
-    };
+    }, "tryConnect");
     tryConnect();
   });
-};
+}, "waitForHostPort");
 
 // src/runCLI.ts
 var config;
-var version = isDefined13("1.11.0") ? "1.11.0" : "unknown";
-var getContextFromConfig = (config3) => {
+var version = isDefined13("1.12.1") ? "1.12.1" : "unknown";
+var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
   const logger = initLogger(config3);
   const orchestrator = new Orchestrator(logger);
   process.on("SIGINT", () => {
@@ -1599,8 +1597,11 @@ var getContextFromConfig = (config3) => {
       }
     })();
   });
-  return { logger, orchestrator };
-};
+  return {
+    logger,
+    orchestrator
+  };
+}, "getContextFromConfig");
 async function runCLI() {
   const y = yargs(hideBin(process.argv));
   const argv = y.usage(`
@@ -1611,9 +1612,7 @@ 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").middleware((argv2) => {
     try {
       const parsedConfigFile = tryParseConfig();
@@ -1630,30 +1629,45 @@ $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").version(version).argv;
   await argv;
 }
+__name(runCLI, "runCLI");
 
 // src/start.ts
 import { config as config2 } from "dotenv";
-var start = async () => {
-  config2({ quiet: true });
+var start = /* @__PURE__ */ __name(async () => {
+  config2({
+    quiet: true
+  });
   await runCLI();
-};
+}, "start");
 export {
   Actor,
   BalanceActor,