@xyo-network/xl1-cli-lib 1.7.4

package/dist/node/index.mjs

@@ -0,0 +1,1712 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/orchestration/actor/implementation/BalanceActor.ts
+import { assertEx } from "@xylabs/assert";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { Mutex } from "async-mutex";
+
+// src/orchestration/actor/model/Actor.ts
+import { Base } from "@xylabs/base";
+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
+    });
+    this._displayName = displayName;
+    this._id = id;
+  }
+  get displayName() {
+    return this._displayName;
+  }
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  get logPrefix() {
+    return `[${this.displayName} (${this.id})] `;
+  }
+  /**
+  * 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.`);
+      return;
+    }
+    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));
+      }
+    }, "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);
+  }
+  async spanAsync(name, fn) {
+    return await spanAsync(`${this.name}:${name}`, fn, this.tracer);
+  }
+  /**
+  * 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.
+  */
+  async stop() {
+    await Promise.resolve();
+    this._active = false;
+    this.logger?.log("Stopping all timers...");
+    for (const [, timerRef] of this._timers.entries()) {
+      clearTimeout(timerRef);
+    }
+    this._timers.clear();
+    this.logger?.log("Stopped.");
+  }
+};
+
+// src/orchestration/actor/model/Orchestrator.ts
+var Orchestrator = class {
+  static {
+    __name(this, "Orchestrator");
+  }
+  actors = [];
+  keepAliveHandle = null;
+  logger;
+  running = false;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+  * Registers an actor.
+  * (We won't activate the actor until `start()` is called.)
+  */
+  async registerActor(actor) {
+    if (this.running) {
+      await actor.start();
+    }
+    this.actors.push(actor);
+  }
+  /**
+  * Starts the orchestrator: activates all actors.
+  */
+  async start() {
+    await Promise.resolve();
+    if (this.running) {
+      this.logger?.warn("[Orchestrator] Already started.");
+      return;
+    }
+    this.logger?.log("[Orchestrator] Starting...");
+    this.running = true;
+    for (const actor of this.actors) {
+      await actor.start();
+    }
+    this.keepAliveHandle = setInterval(() => {
+    }, 2147483647);
+  }
+  /**
+  * Stops the orchestrator: deactivates all actors.
+  */
+  async stop() {
+    await Promise.resolve();
+    if (!this.running) {
+      this.logger?.log("[Orchestrator] Already stopped.");
+      return;
+    }
+    this.logger?.log("[Orchestrator] Stopping...");
+    for (const actor of this.actors) {
+      await actor.stop();
+    }
+    this.running = false;
+    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle);
+    this.logger?.log("[Orchestrator] Stopped...");
+  }
+};
+
+// 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);
+  }
+  get balanceService() {
+    return assertEx(this.params.balanceService, () => "balanceService not set");
+  }
+  get chainIterator() {
+    return assertEx(this.params.chainIterator, () => "chainIterator not set");
+  }
+  static create(params) {
+    return new _BalanceActor(params);
+  }
+  async start() {
+    await super.start();
+    this.chainIterator.on("headUpdate", async () => {
+      await this.updateBalance();
+    });
+    this.registerTimer("BalanceTimer", async () => {
+      await this.updateBalance();
+    }, 1e3, 1e3);
+  }
+  async updateBalance() {
+    if (this._updateMutex.isLocked()) return;
+    await this._updateMutex.runExclusive(async () => {
+      const head = await PayloadBuilder.hash(await this.chainIterator.head());
+      await this.balanceService.balances(head, []);
+    });
+  }
+};
+
+// src/orchestration/actor/implementation/ChainHeadUpdateActor.ts
+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 { asBlockBoundWitness } from "@xyo-network/xl1-protocol";
+var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
+  static {
+    __name(this, "ChainHeadUpdateActor");
+  }
+  constructor(params) {
+    super("ChainHeadUpdate", "ChainHeadUpdate", params);
+  }
+  get chainFinalizedArchivist() {
+    return assertEx2(this.params.chainArchivist, () => "ChainArchivist not set");
+  }
+  get chainIterator() {
+    return assertEx2(this.params.chainIterator, () => "chainIterator not set");
+  }
+  static create(params) {
+    return new _ChainHeadUpdateActor(params);
+  }
+  async start() {
+    await super.start();
+    this.chainFinalizedArchivist.on("inserted", async (data) => {
+      await this.checkInsertedForNewHead(data);
+    });
+    this.registerTimer("ChainHeadUpdateTimer", async () => await this.pollForNewHead(), 0, 250);
+  }
+  async checkInsertedForNewHead(data) {
+    const candidateBlock = sortBlocks(filterAs(data.payloads, asBlockBoundWitness)).at(-1);
+    await this.updateHeadIfNewer(candidateBlock);
+  }
+  async pollForNewHead() {
+    const candidateBlock = await findMostRecentBlock(this.chainFinalizedArchivist);
+    await this.updateHeadIfNewer(candidateBlock);
+  }
+  async updateHeadIfNewer(candidateBlock) {
+    if (!candidateBlock) return;
+    const currentHead = await this.chainIterator.head();
+    const candidateBlockNumber = candidateBlock.block;
+    const candidateBlockNumberDisplay = `0x${toHex(candidateBlockNumber)}`;
+    const currentBlockNumber = currentHead?.block ?? -1;
+    if (candidateBlockNumber > currentBlockNumber) {
+      this.logger?.log("Found more recent head:", candidateBlockNumberDisplay);
+      await this.chainIterator.updateHead(candidateBlock);
+      this.logger?.log("Updated head:", candidateBlockNumberDisplay);
+    }
+  }
+};
+
+// src/orchestration/actor/implementation/ProducerActor.ts
+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 { 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";
+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) {
+    super(params.producer.address, "Producer", params);
+  }
+  get account() {
+    return assertEx3(this.params.account, () => "account not set");
+  }
+  get balanceService() {
+    return assertEx3(this.params.balanceService, () => "balanceService not set");
+  }
+  get chainIterator() {
+    return assertEx3(this.params.chainIterator, () => "chainIterator not set");
+  }
+  get chainStakeViewer() {
+    return assertEx3(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+  }
+  get chainSubmissionsArchivistWrite() {
+    return assertEx3(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
+  }
+  get pendingBundledTransactionsArchivistWrite() {
+    return assertEx3(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
+  }
+  get producer() {
+    return assertEx3(this.params.producer, () => "producer not set");
+  }
+  get stakeIntentService() {
+    return assertEx3(this.params.stakeIntentService, () => "stakeIntentService not set");
+  }
+  static create(params) {
+    return new _ProducerActor(params);
+  }
+  async start() {
+    await super.start();
+    this.registerTimer("BlockProductionTimer", async () => {
+      await this.spanAsync("produceBlock", async () => {
+        const head = await this.chainIterator.head();
+        const headHash = await PayloadBuilder2.hash(head);
+        if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
+          this.logger?.log("Block already produced:", `0x${toHex2(this._lastProducedBlock[0].block)}`);
+        } else {
+          const nextBlock = await this.producer.next(head);
+          if (nextBlock) {
+            const displayBlockNumber = `0x${toHex2(nextBlock[0].block)}`;
+            this.logger?.log("Produced block:", displayBlockNumber);
+            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
+            this.logger?.log("Published block:", displayBlockNumber);
+            this._lastProducedBlock = nextBlock;
+          }
+        }
+      });
+    }, 100, 500);
+    if (SHOULD_REGISTER_REDECLARATION_INTENT_TIMER) {
+      this.registerTimer("ProducerRedeclarationTimer", async () => {
+        await this.spanAsync("producerRedeclarationTimer", async () => {
+          if (this.params.config.producer.disableIntentRedeclaration) return;
+          const head = await this.chainIterator.head();
+          if (isUndefined(head)) return;
+          const currentBlock = head.block;
+          const blocksUntilExpiration = await this.calculateBlocksUntilProducerDeclarationExpiration(currentBlock);
+          if (blocksUntilExpiration > BaseBlockProducerService.RedeclarationWindow * 0.1) {
+            this._lastRedeclarationIntent = void 0;
+            return;
+          }
+          if (this._lastRedeclarationIntent) {
+            if (this._lastRedeclarationIntent.exp > currentBlock) return;
+            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.`);
+            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.`);
+            return;
+          }
+          this.logger?.log("Creating redeclaration intent for producer:", this.account.address);
+          const redeclarationIntent = createDeclarationIntent(this.account.address, "producer", currentBlock, currentBlock + BaseBlockProducerService.RedeclarationDuration);
+          await this.submitRedeclarationIntent(currentBlock, redeclarationIntent);
+          this._lastRedeclarationIntent = redeclarationIntent;
+        });
+      }, 1e4, TEN_MINUTES);
+    }
+  }
+  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 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 payloads = flattenHydratedTransaction(tx);
+    const root = tx[0]._hash;
+    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 currentBalance = balances[this.account.address] ?? 0n;
+      if (currentBalance <= 0n) {
+        this.logger?.error(`Producer ${this.account.address} has no balance.`);
+        return false;
+      }
+      return true;
+    }
+    return true;
+  }
+  async validateCurrentStake() {
+    const requiredMinimumStake = this.stakeIntentService.getRequiredMinimumStakeForIntent("producer");
+    const currentStake = await this.chainStakeViewer.activeByAddressStaked(this.account.address);
+    if (currentStake < requiredMinimumStake) {
+      this.logger?.error(`Producer ${this.account.address} has insufficient stake.`);
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/orchestration/actor/implementation/ValidatorActor.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+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) {
+    super("Validator", "Validator", params);
+  }
+  get account() {
+    return assertEx4(this.params.account, () => "account not set");
+  }
+  get balanceService() {
+    return assertEx4(this.params.balanceService, () => "balanceService not set");
+  }
+  get chainIterator() {
+    return assertEx4(this.params.chainIterator, () => "chainIterator not set");
+  }
+  get chainStakeViewer() {
+    return assertEx4(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+  }
+  get chainSubmissionsArchivistWrite() {
+    return assertEx4(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
+  }
+  get pendingBundledTransactionsArchivistWrite() {
+    return assertEx4(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
+  }
+  get stakeIntentService() {
+    return assertEx4(this.params.stakeIntentService, () => "stakeIntentService not set");
+  }
+  // protected get validator() {
+  //   return assertEx(this.params.validator, () => 'validator not set')
+  // }
+  static create(params) {
+    return new _ValidatorActor(params);
+  }
+  async start() {
+    await super.start();
+    this.registerTimer("BlockProductionTimer", async () => {
+      await this.spanAsync("produceBlock", async () => {
+        const block = await this.chainIterator.head();
+        if (isUndefined2(block)) return;
+        const hash = await PayloadBuilder3.hash(block);
+        if (isDefined2(this._lastValidatedBlock) && this._lastValidatedBlockHash === hash) {
+          this.logger?.log("Block already validated:", `0x${toHex3(block.block)}`);
+        } else {
+          this.logger?.log("Validating block:", `0x${toHex3(block.block)}`);
+          const valid = await this.validateBlock(block);
+          if (valid) {
+            this.logger?.log("Validated block:", `0x${toHex3(block.block)}`);
+          } else {
+            this.logger?.log("Invalid block:", `0x${toHex3(block.block)}`);
+            await this.slashInvalidBlock(block);
+          }
+        }
+      });
+    }, 100, 500);
+  }
+  async slashInvalidBlock(_block) {
+    const slashed = await Promise.resolve(true);
+    return slashed;
+  }
+  async validateBlock(block) {
+    const valid = await Promise.resolve(true);
+    this._lastValidatedBlock = block;
+    this._lastValidatedBlockHash = await PayloadBuilder3.hash(block);
+    return valid;
+  }
+};
+
+// src/orchestration/health/initHealthEndpoints.ts
+import http from "http";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+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
+  }));
+}, "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();
+    switch (url) {
+      case "/healthz": {
+        sendStatus(res, status, 500);
+        break;
+      }
+      case "/livez": {
+        sendStatus(res, status, 503);
+        break;
+      }
+      case "/readyz": {
+        sendStatus(res, status, 503);
+        break;
+      }
+      default: {
+        notFound(res);
+      }
+    }
+  });
+  server.listen(port, () => {
+    logger.log(`Health server running on http://localhost:${port}`);
+    logger.log(" - /healthz");
+    logger.log(" - /livez");
+    logger.log(" - /readyz");
+  });
+  return server;
+}, "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";
+
+// src/orchestration/archivists/ChainFinalized/archivist.ts
+import { initArchivistSync } from "@xyo-network/chain-orchestration";
+import { startupSpanAsync } from "@xyo-network/chain-utils";
+import { Mutex as Mutex4 } from "async-mutex";
+
+// src/orchestration/archivists/ChainFinalized/local.ts
+import { Mutex as Mutex2 } from "async-mutex";
+
+// src/orchestration/archivists/lib/localPersistentArchivist.ts
+import { rm } from "fs/promises";
+import Path2 from "path";
+import { LmdbArchivist, LmdbArchivistConfigSchema } from "@xyo-network/archivist-lmdb";
+
+// src/orchestration/store/getStoreDirectory.ts
+import Path from "path";
+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 = /* @__PURE__ */ __name((dbName, storeName, storageRoot, kind = "lmdb") => {
+  switch (kind) {
+    case "lmdb": {
+      const root = storageRoot ?? DEFAULT_STORAGE_ROOT;
+      return LmdbArchivist.create({
+        account: "random",
+        config: {
+          clearStoreOnStart: false,
+          dbName,
+          location: getStoreDirectory(dbName, root, "lmdb"),
+          schema: LmdbArchivistConfigSchema,
+          storeName
+        }
+      });
+    }
+  }
+}, "getLocalPersistentArchivist");
+
+// src/orchestration/archivists/ChainFinalized/local.ts
+var mutex = new Mutex2();
+var singleton;
+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 { 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 }) => {
+  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"
+    });
+    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 }) {
+  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
+      }))
+    ]);
+    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 { 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 { 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 }) => {
+  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"
+    });
+    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) => {
+  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 { Mutex as Mutex9 } from "async-mutex";
+
+// src/orchestration/archivists/PendingTransactions/local.ts
+import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
+import { Mutex as Mutex7 } from "async-mutex";
+var mutex6 = new Mutex7();
+var singleton6;
+var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex6.runExclusive(async () => {
+    if (singleton6) return singleton6;
+    singleton6 = await MemoryArchivist.create({
+      account: "random",
+      config: {
+        schema: MemoryArchivistConfigSchema,
+        max: 1e3,
+        name: "localPendingTransactions"
+      }
+    });
+    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 { 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 }) => {
+  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"
+    });
+    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) => {
+  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"
+    });
+    await local.insert(start2);
+    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 { Mutex as Mutex11 } from "async-mutex";
+
+// src/orchestration/archivists/RejectedTransactions/local.ts
+import { MemoryArchivist as MemoryArchivist2, MemoryArchivistConfigSchema as MemoryArchivistConfigSchema2 } from "@xyo-network/archivist-memory";
+import { Mutex as Mutex10 } from "async-mutex";
+var mutex9 = new Mutex10();
+var singleton9;
+var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex9.runExclusive(async () => {
+    if (singleton9) return singleton9;
+    singleton9 = await MemoryArchivist2.create({
+      account: "random",
+      config: {
+        schema: MemoryArchivistConfigSchema2,
+        max: 1e3,
+        name: "localRejectedTransactions"
+      }
+    });
+    return singleton9;
+  });
+}, "initLocalRejectedTransactionsArchivist");
+
+// src/orchestration/archivists/RejectedTransactions/archivist.ts
+var mutex10 = new Mutex11();
+var singleton10;
+async function initRejectedTransactionsArchivist(params) {
+  return await mutex10.runExclusive(async () => {
+    if (singleton10) return singleton10;
+    const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
+    singleton10 = local;
+    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 { Mutex as Mutex13 } from "async-mutex";
+
+// src/orchestration/archivists/StakeIntentState/local.ts
+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 }) => {
+  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) => {
+  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 { Mutex as Mutex15 } from "async-mutex";
+
+// src/orchestration/map/BalanceSummary/local.ts
+import { isDefined as isDefined4 } from "@xylabs/typeof";
+import { Mutex as Mutex14 } from "async-mutex";
+
+// src/orchestration/map/localPersistentMap.ts
+import { rm as rm2 } from "fs/promises";
+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");
+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.
+  */
+  get folderPath() {
+    return `${this.params.location}/${this.params.dbName}`;
+  }
+  all() {
+    return [
+      ...this.db.getRange({})
+    ].map((entry) => entry.value);
+  }
+  clear() {
+    this.db.clearSync();
+  }
+  delete(id) {
+    return this.db.removeSync(id);
+  }
+  get(id) {
+    return this.db.get(id);
+  }
+  has(id) {
+    return this.db.doesExist(id);
+  }
+  set(id, data) {
+    this.db.putSync(id, data);
+    return this;
+  }
+  async startHandler() {
+    await super.startHandler();
+    this.rootDatabase = open({
+      path: this.folderPath
+    });
+    this.db = this.rootDatabase.openDB({
+      name: this.params.storeName
+    });
+  }
+};
+SynchronousLmdbMap = _ts_decorate([
+  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") => {
+  switch (kind) {
+    case "lmdb": {
+      const root = storageRoot ?? DEFAULT_STORAGE_ROOT2;
+      const location = getStoreDirectory(dbName, root, "lmdb");
+      const store = await SynchronousLmdbMap.create({
+        location,
+        dbName,
+        storeName
+      });
+      return store;
+    }
+  }
+}, "getLocalPersistentMap");
+
+// src/orchestration/map/BalanceSummary/local.ts
+var mutex13 = new Mutex14();
+var singleton13;
+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();
+var singleton14;
+async function initBalanceSummaryMap(params) {
+  return await mutex14.runExclusive(async () => {
+    if (isDefined5(singleton14)) return singleton14;
+    const local = await startupSpanAsync6("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap(params));
+    singleton14 = local;
+    return singleton14;
+  });
+}
+__name(initBalanceSummaryMap, "initBalanceSummaryMap");
+
+// src/orchestration/services/implementation/account.ts
+import { isUndefined as isUndefined3 } from "@xylabs/typeof";
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/chain-protocol";
+import { HDWallet } from "@xyo-network/wallet";
+var accountServiceSingleton;
+var initAccount = /* @__PURE__ */ __name(async ({ config: config3, logger }) => {
+  if (accountServiceSingleton) return accountServiceSingleton;
+  let walletPhrase = config3.producer.mnemonic;
+  if (isUndefined3(walletPhrase)) {
+    logger?.log("No wallet mnemonic specified!");
+    const randomMnemonic = HDWallet.generateMnemonic();
+    logger?.log(`Using randomly generated mnemonic: ${randomMnemonic}`);
+    walletPhrase = randomMnemonic;
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  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) => {
+  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";
+
+// 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 { Wallet } from "ethers/wallet";
+
+// src/orchestration/services/implementation/evm/initEvmProvider.ts
+import { assertEx as assertEx14 } from "@xylabs/assert";
+
+// src/orchestration/services/implementation/evm/initInfuraProvider.ts
+import { assertEx as assertEx12 } from "@xylabs/assert";
+import { isDefined as isDefined7 } from "@xylabs/typeof";
+import { InfuraProvider } from "ethers/providers";
+
+// src/orchestration/services/implementation/evm/initChainId.ts
+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) => {
+  return isDefined6(config3.evm.chainId);
+}, "canUseChainId");
+var getChainId = /* @__PURE__ */ __name((config3) => {
+  const chainId = assertEx11(config3.evm.chainId, () => "Missing config.evm.chainId");
+  if (isHex(chainId, {
+    prefix: true
+  })) {
+    const hex = hexFrom(chainId);
+    const parsed = Number.parseInt(hex, 16);
+    return parsed;
+  } else {
+    const parsed = Number.parseInt(chainId, 10);
+    return parsed;
+  }
+}, "getChainId");
+
+// src/orchestration/services/implementation/evm/initInfuraProvider.ts
+var instance;
+var initInfuraProvider = /* @__PURE__ */ __name((config3) => {
+  if (instance) return instance;
+  const providerConfig = getInfuraProviderConfig(config3);
+  instance = Promise.resolve(new InfuraProvider(...providerConfig));
+  return instance;
+}, "initInfuraProvider");
+var canUseInfuraProvider = /* @__PURE__ */ __name((config3) => {
+  return canUseChainId(config3) && isDefined7(config3.evm?.infura?.projectId) && isDefined7(config3.evm?.infura?.projectSecret);
+}, "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
+  ];
+}, "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 = /* @__PURE__ */ __name((config3) => {
+  const providerConfig = getJsonRpcProviderConfig(config3);
+  return Promise.resolve(new JsonRpcProvider(...providerConfig));
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider = /* @__PURE__ */ __name((config3) => {
+  return canUseChainId(config3) && isDefined8(config3.evm.jsonRpc?.url);
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config3) => {
+  const jsonRpcUrl = assertEx13(config3.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  return [
+    jsonRpcUrl,
+    getChainId(config3)
+  ];
+}, "getJsonRpcProviderConfig");
+
+// src/orchestration/services/implementation/evm/initEvmProvider.ts
+var provider;
+var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config3 }) => {
+  if (provider) return provider;
+  if (canUseInfuraProvider(config3)) {
+    provider = initInfuraProvider(config3);
+  } else if (canUseJsonRpcProvider(config3)) {
+    provider = initJsonRpcProvider(config3);
+  }
+  return assertEx14(await provider, () => "Error: No provider available");
+}, "initEvmProvider");
+var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config3 }) => {
+  return canUseInfuraProvider(config3) || canUseJsonRpcProvider(config3);
+}, "canUseEvmProvider");
+
+// src/orchestration/services/implementation/chain/evm.ts
+var chainStakeServiceSingleton;
+var canUseEvmContractChainService = /* @__PURE__ */ __name((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 }) => {
+  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 privateKey = assertEx15(account.private?.hex, () => "Error: Account does not have a private key");
+  const runner = new Wallet(privateKey, provider2);
+  chainStakeServiceSingleton = EvmChainService.create({
+    id,
+    runner,
+    traceProvider,
+    meterProvider,
+    logger
+  });
+  return await chainStakeServiceSingleton;
+}, "initEvmContractChainService");
+
+// src/orchestration/services/implementation/chain/index.ts
+var chainStakeServiceSingleton2;
+var initChainService = /* @__PURE__ */ __name(({ account, config: config3 }) => init({
+  config: config3,
+  name: "ChainService",
+  account
+}), "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"
+  });
+  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 { flattenHydratedBlock as flattenHydratedBlock2 } from "@xyo-network/xl1-protocol-sdk";
+var headSingleton;
+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
+    ]);
+    if (result.length > 0) break;
+    await delay(1e3);
+  }
+  return bw;
+}, "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";
+var chainIteratorServiceSingleton;
+var stakeIntentServiceSingleton;
+var electionServiceSingleton;
+var initChainIterator = /* @__PURE__ */ __name((params) => {
+  if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
+  chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
+  return chainIteratorServiceSingleton;
+}, "initChainIterator");
+var initStakeIntentService = /* @__PURE__ */ __name((params) => {
+  if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
+  stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
+  return stakeIntentServiceSingleton;
+}, "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";
+var serviceSingleton;
+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";
+var serviceSingleton2;
+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";
+var rewardServiceSingleton;
+var initBlockRewardService = /* @__PURE__ */ __name((params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  const { config: config3 } = params;
+  rewardServiceSingleton = canUseEvmBlockRewardService({
+    config: config3
+  }) ? initEvmBlockRewardService(params) : initXyoBlockRewardService(params);
+  return rewardServiceSingleton;
+}, "initBlockRewardService");
+var initXyoBlockRewardService = /* @__PURE__ */ __name((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) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  const { account: paramsAccount } = params;
+  const account = assertEx16(paramsAccount, () => "Error: Account is required");
+  const provider2 = assertEx16(await initEvmProvider(params));
+  const evmBlockRewardServiceParams = {
+    ...params,
+    provider: provider2,
+    account
+  };
+  rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams);
+  return rewardServiceSingleton;
+}, "initEvmBlockRewardService");
+
+// src/orchestration/services/implementation/validator.ts
+var serviceSingleton3;
+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) {
+    this.logger = logger;
+  }
+  report(name, status, progress) {
+    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
+    });
+  }
+};
+
+// src/orchestration/status/RuntimeStatusMonitor.ts
+var statusPriority = {
+  error: 0,
+  stopped: 1,
+  stopping: 2,
+  creating: 3,
+  created: 4,
+  starting: 5,
+  started: 6
+};
+var SENTINEL_STATUS = "starting";
+var reduceToMinimumStatus = /* @__PURE__ */ __name((statuses) => {
+  let minStatus = SENTINEL_STATUS;
+  let minPriority = Infinity;
+  for (const status of statuses) {
+    const priority = statusPriority[status];
+    if (priority < minPriority) {
+      minPriority = priority;
+      minStatus = status;
+    }
+  }
+  return minStatus;
+}, "reduceToMinimumStatus");
+var RuntimeStatusMonitor = class extends LoggerStatusReporter {
+  static {
+    __name(this, "RuntimeStatusMonitor");
+  }
+  globalTransitions = [];
+  transitions = [];
+  getGlobalStatus() {
+    if (Object.keys(this.statusMap).length === 0) return SENTINEL_STATUS;
+    return reduceToMinimumStatus(Object.values(this.statusMap));
+  }
+  getStatus(name) {
+    return this.statusMap[name];
+  }
+  onGlobalTransition(match, handler) {
+    this.globalTransitions.push({
+      ...match,
+      handler
+    });
+  }
+  /**
+  * Register a callback to be called on a specific transition.
+  */
+  onTransition(match, handler) {
+    this.transitions.push({
+      ...match,
+      handler
+    });
+  }
+  report(name, status, progress) {
+    const previous = this.statusMap[name];
+    const previousGlobal = this.getGlobalStatus();
+    super.report(name, status, progress);
+    if (previous === status) return;
+    this.runTransitions(this.transitions, previous, status, name);
+    const globalStatus = this.getGlobalStatus();
+    if (previousGlobal === globalStatus) return;
+    this.runTransitions(this.globalTransitions, previousGlobal, globalStatus);
+  }
+  runTransitions(transitions, prev, next, name) {
+    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);
+      }
+    }
+  }
+};
+
+// src/orchestration/initServices.ts
+var telemetryConfig = {
+  attributes: {
+    serviceName: "xl1-producer",
+    serviceVersion: "1.0.0"
+  },
+  metricsConfig: {
+    endpoint: "/metrics",
+    port: 9464
+  }
+};
+var isStartable = /* @__PURE__ */ __name((value) => {
+  return isDefined10(value.start) && typeof value.start === "function";
+}, "isStartable");
+var initServices = /* @__PURE__ */ __name(async (context) => {
+  const { config: config3, logger } = context;
+  const statusReporter = new RuntimeStatusMonitor(logger);
+  statusReporter.onGlobalTransition({
+    to: "started"
+  }, () => {
+    logger.log("All services started.");
+  });
+  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([
+    startupSpanAsync7("initTelemetry", () => initTelemetry(telemetryConfig)),
+    startupSpanAsync7("initAccount", () => initAccount(context))
+  ]);
+  const initParams = {
+    config: config3,
+    logger,
+    meterProvider,
+    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 chainId = chainService.chainId;
+  const chainContractViewer = chainService;
+  const chainStakeViewer = chainService;
+  const chainStaker = chainService;
+  const head = await startupSpanAsync7("initHead", () => initHead({
+    ...initParams,
+    account,
+    chainArchivist,
+    chainSubmissionsArchivistWrite
+  }));
+  const [pendingTransactionsService, rewardService, chainIterator, balanceService] = await Promise.all([
+    startupSpanAsync7("PendingTransactions", () => initPendingTransactions({
+      name: "PendingTransactionsService",
+      chainArchivist,
+      chainId,
+      pendingBundledTransactionsArchivist,
+      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",
+    chainArchivist,
+    chainIterator,
+    chainStakeViewer,
+    stakeIntentStateArchivist,
+    ...initParams
+  }));
+  const electionService = await startupSpanAsync7("ElectionService", () => initElectionService({
+    name: "ElectionService",
+    chainIterator,
+    chainStakeViewer,
+    stakeIntentService,
+    ...initParams
+  }));
+  const validatorParams = {
+    name: "Validator",
+    account,
+    chainId,
+    pendingBundledTransactionsArchivist,
+    chainArchivist,
+    electionService,
+    rewardService,
+    stakeIntentService,
+    validateHydratedBlockState,
+    ...initParams
+  };
+  const rewardAddress = isDefined10(config3.producer.rewardAddress) ? assertEx17(asAddress2(config3.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
+  const producerParams = {
+    ...validatorParams,
+    name: "Producer",
+    balanceService,
+    chainArchivist,
+    pendingBundledTransactionsArchivist,
+    pendingTransactionsService,
+    rejectedTransactionsArchivist,
+    rewardAddress,
+    ...initParams
+  };
+  const producer = await startupSpanAsync7("Producer", () => initBlockProducer(producerParams));
+  const result = {
+    account,
+    balanceService,
+    chainArchivist,
+    chainContractViewer,
+    chainIterator,
+    chainStaker,
+    chainStakeViewer,
+    chainSubmissionsArchivistWrite,
+    electionService,
+    pendingBundledTransactionsArchivistWrite,
+    pendingTransactionsService,
+    producer,
+    rewardService,
+    stakeIntentService
+  };
+  logger?.log("All services created. Starting...");
+  const startableServices = [
+    balanceSummaryMap,
+    ...Object.values(result)
+  ].filter(isStartable);
+  await Promise.all(startableServices.map((service) => service.start()));
+  return result;
+}, "initServices");
+
+// src/runCLI.ts
+import { isDefined as isDefined12 } from "@xylabs/typeof";
+import { ConfigSchema } from "@xyo-network/xl1-protocol-sdk";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { ZodError } from "zod";
+
+// src/commands/api/runApi.ts
+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;
+  logger?.log("Services: Initializing...");
+  const services = await initServices(context);
+  logger?.log("Services: Initialized");
+  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
+  ];
+  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
+\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\x1B[0m\x1B[38;2;72;32;223m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m
+\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\u2560\u2560\x1B[0m\x1B[38;2;103;85;170m_\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;79;121;152m\u2566\x1B[0m\x1B[38;2;82;121;151m\u2566\x1B[0m\x1B[38;2;112;125;136m_\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;88;59;196m[\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;73;34;221m\u2592\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;121;121;127m_\x1B[0m\x1B[38;2;100;101;128m\u2554\x1B[0m\x1B[38;2;93;94;127m\u2566\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;82;121;151m\xB2\x1B[0m\x1B[38;2;44;116;170m\u2560\x1B[0m\x1B[38;2;44;116;171m\u2592\x1B[0m\x1B[38;2;51;117;167mD\x1B[0m\x1B[38;2;80;121;152m\u2566\x1B[0m\x1B[38;2;111;125;136m_\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;67;23;232m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;120;121;128m_\x1B[0m\x1B[38;2;100;101;127m\u2554\x1B[0m\x1B[38;2;79;81;127mR\x1B[0m\x1B[38;2;71;73;128m\u2592\x1B[0m\x1B[38;2;71;73;128m\u2592\x1B[0m\x1B[38;2;88;90;127m\u2559\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;55;117;165m\u255A\x1B[0m\x1B[38;2;44;116;171m\u2592\x1B[0m\x1B[38;2;44;116;171m\u2592\u2592\x1B[0m\x1B[38;2;50;116;167mD\x1B[0m\x1B[38;2;80;121;152m\u2566\xA0\x1B[0m\x1B[38;2;106;90;165mj\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\x1B[0m\x1B[38;2;89;61;194mH\xA0\x1B[0m\x1B[38;2;99;100;127m\u2554\x1B[0m\x1B[38;2;79;80;127mD\x1B[0m\x1B[38;2;71;73;128m\u2592\x1B[0m\x1B[38;2;71;73;128m\u2592\u2592\u2560\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;83;121;150m\xB2\x1B[0m\x1B[38;2;44;116;170m\u2592\x1B[0m\x1B[38;2;44;116;171m\u2592\u2592\u2592\xA0\x1B[0m\x1B[38;2;76;38;217m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\u2560\xA0\x1B[0m\x1B[38;2;74;76;128m\u2560\x1B[0m\x1B[38;2;71;73;128m\u2592\u2592\u2592\x1B[0m\x1B[38;2;89;90;128m\u2559\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;90;118;148m\`\x1B[0m\x1B[38;2;89;107;153m_\x1B[0m\x1B[38;2;93;97;154m,\x1B[0m\x1B[38;2;105;89;166m\u2553\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\u2560\u2560\x1B[0m\x1B[38;2;95;72;183m\u2553\x1B[0m\x1B[38;2;106;96;152m_\x1B[0m\x1B[38;2;100;94;143m\`\x1B[0m\x1B[38;2;101;100;133m\`\x1B[0m
+\x1B[38;2;128;128;128m\xA0\x1B[0m\x1B[38;2;122;118;137m_\x1B[0m\x1B[38;2;113;102;153m,\x1B[0m\x1B[38;2;108;94;161m\u2553\x1B[0m\x1B[38;2;104;86;169m\u2553\x1B[0m\x1B[38;2;98;77;178m\u2554\x1B[0m\x1B[38;2;93;67;188m\u2557\x1B[0m\x1B[38;2;88;59;196m\u03C6\x1B[0m\x1B[38;2;83;51;204m@\x1B[0m\x1B[38;2;78;42;213mD\x1B[0m\x1B[38;2;72;32;223m\u2592\x1B[0m\x1B[38;2;68;24;231m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\x1B[0m\x1B[38;2;71;30;225m\u2592\x1B[0m\x1B[38;2;77;40;215m\u2592\x1B[0m\x1B[38;2;82;49;206mK\x1B[0m\x1B[38;2;87;57;198m\u03C6\x1B[0m\x1B[38;2;91;65;190m\u2557\x1B[0m\x1B[38;2;97;75;180m\u2566\x1B[0m\x1B[38;2;103;84;171m\u2556\x1B[0m\x1B[38;2;107;92;163m\xB2\x1B[0m\x1B[38;2;112;101;154m_\x1B[0m\x1B[38;2;119;112;143m_\x1B[0m
+\x1B[38;2;128;128;128m\xA0\x1B[0m\x1B[38;2;106;91;164m\`\x1B[0m\x1B[38;2;94;70;185m^\x1B[0m\x1B[38;2;89;62;193m\u2559\x1B[0m\x1B[38;2;85;54;201m\u2559\x1B[0m\x1B[38;2;80;45;210m\u255A\x1B[0m\x1B[38;2;74;35;220m\u255D\x1B[0m\x1B[38;2;69;26;229m\u2560\x1B[0m\x1B[38;2;66;22;233m\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\u2560\x1B[0m\x1B[38;2;73;33;222m\u255D\x1B[0m\x1B[38;2;79;43;212m\u2569\x1B[0m\x1B[38;2;84;52;203m\u255C\x1B[0m\x1B[38;2;88;60;195m\u2559\x1B[0m\x1B[38;2;93;68;187m^\x1B[0m\x1B[38;2;100;80;175m\`\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;113;84;152m\`\x1B[0m\x1B[38;2;103;79;169m'\x1B[0m\x1B[38;2;95;72;183m"\x1B[0m\x1B[38;2;87;57;198m\u2559\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\u2560\u2560\x1B[0m\x1B[38;2;80;46;209m\u255C\x1B[0m\x1B[38;2;94;70;185m^\x1B[0m\x1B[38;2;102;77;175m^\x1B[0m\x1B[38;2;112;81;162m\`\x1B[0m\x1B[38;2;115;92;155m\`\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;145;116;107m,\x1B[0m\x1B[38;2;199;82;45m\u2560\x1B[0m\x1B[38;2;207;77;35m\u2592\x1B[0m\x1B[38;2;207;77;35m\u2592\u2560\xA0\x1B[0m\x1B[38;2;70;28;227m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\u2560\xA0\x1B[0m\x1B[38;2;189;49;97m\xE5\x1B[0m\x1B[38;2;203;32;90m\u2560\x1B[0m\x1B[38;2;203;32;90m\u2560\u2560\x1B[0m\x1B[38;2;155;92;114m,\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;175;98;73m\u2554\x1B[0m\x1B[38;2;207;77;35m\u2592\x1B[0m\x1B[38;2;207;77;35m\u2592\u2592\u2592\x1B[0m\x1B[38;2;197;83;47m\u2569\xA0\x1B[0m\x1B[38;2;98;76;179m[\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\x1B[0m\x1B[38;2;81;48;207mH\xA0\x1B[0m\x1B[38;2;188;51;98m\u255A\x1B[0m\x1B[38;2;203;32;90m\u2560\x1B[0m\x1B[38;2;203;32;90m\u2560\u2560\u2560\x1B[0m\x1B[38;2;183;57;100mH\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;146;116;106m,\x1B[0m\x1B[38;2;199;82;44m\u2560\x1B[0m\x1B[38;2;207;77;35m\u2592\x1B[0m\x1B[38;2;207;77;35m\u2592\x1B[0m\x1B[38;2;196;84;48m\u2569\x1B[0m\x1B[38;2;168;102;81m^\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\u2560\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;160;87;111m'\x1B[0m\x1B[38;2;187;52;98m\u255A\x1B[0m\x1B[38;2;203;32;90m\u2560\x1B[0m\x1B[38;2;203;32;90m\u2560\u2560\x1B[0m\x1B[38;2;156;91;113m,\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;198;83;46m\u2569\x1B[0m\x1B[38;2;194;85;50m\u2569\x1B[0m\x1B[38;2;167;102;82m^\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;81;46;209m\u255A\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\u2560\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;159;88;112m'\x1B[0m\x1B[38;2;186;53;98m\u255A\x1B[0m\x1B[38;2;197;40;93m\u2569\x1B[0m
+\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;110;97;158m'\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m\x1B[38;2;94;69;186mH\x1B[0m
+\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\x1B[0m\x1B[38;2;68;25;230m\u2560\x1B[0m\x1B[38;2;66;21;234m\u2560\x1B[0m
+\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\x1B[0m\x1B[38;2;108;93;162m\xB2\x1B[0m\x1B[38;2;99;79;176m^\x1B[0m`;
+
+// src/initLogger.ts
+import { Base as Base2 } from "@xylabs/base";
+import { ConsoleLogger, LogLevel, SilentLogger } from "@xylabs/logger";
+import { isDefined as isDefined11 } from "@xylabs/typeof";
+var initLogger = /* @__PURE__ */ __name((config3) => {
+  let logger;
+  if (config3.silent) {
+    logger = new SilentLogger();
+  } else {
+    let level;
+    if (isDefined11(config3.logLevel)) {
+      const parsed = LogLevel[config3.logLevel.toLowerCase()];
+      if (isDefined11(parsed)) level = parsed;
+    }
+    logger = new ConsoleLogger(level);
+  }
+  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 = {}) => {
+  if (zodType instanceof ZodObject) {
+    const shape = zodType.shape;
+    for (const [k, v] of Object.entries(shape)) {
+      collectOptions(v, [
+        ...path,
+        k
+      ], out);
+    }
+    return out;
+  }
+  const def = zodType._def;
+  if (def?.innerType instanceof ZodObject) {
+    const shape = def.innerType.shape;
+    for (const [k, v] of Object.entries(shape)) {
+      collectOptions(v, [
+        ...path,
+        k
+      ], out);
+    }
+    return out;
+  }
+  const options = {};
+  options.describe = def.description;
+  options.default = typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+  let type = "string";
+  const typeName = def.typeName === ZodDefault.name || def.typeName === ZodOptional.name ? def.innerType._def.typeName : def.typeName;
+  if (typeName === ZodBoolean.name) type = "boolean";
+  if (typeName === ZodNumber.name || def.coerce) type = "number";
+  if (typeName === ZodEnum.name) {
+    options.choices = Object.values(def.innerType.enum);
+  }
+  options.type = type;
+  const key = path.join(".");
+  out[key] = options;
+  return out;
+}, "collectOptions");
+var optionsFromZodSchema = /* @__PURE__ */ __name((schema) => {
+  const opts = {};
+  for (const [rootKey, zodType] of Object.entries(schema)) {
+    collectOptions(zodType, [
+      rootKey
+    ], opts);
+  }
+  return opts;
+}, "optionsFromZodSchema");
+
+// src/waitForHostPort.ts
+import net from "net";
+var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
+  return new Promise((resolve) => {
+    const tryConnect = /* @__PURE__ */ __name(() => {
+      const socket = new net.Socket();
+      socket.setTimeout(1e3).once("error", () => {
+        socket.destroy();
+        setTimeout(tryConnect, 500);
+      }).once("timeout", () => {
+        socket.destroy();
+        setTimeout(tryConnect, 500);
+      }).connect(port, host, () => {
+        socket.end();
+        resolve();
+      });
+    }, "tryConnect");
+    tryConnect();
+  });
+}, "waitForHostPort");
+
+// src/runCLI.ts
+var config;
+var version = isDefined12("1.7.3") ? "1.7.3" : "unknown";
+var getContextFromConfig = /* @__PURE__ */ __name((config3) => {
+  const logger = initLogger(config3);
+  const orchestrator = new Orchestrator(logger);
+  process.on("SIGINT", () => {
+    void (async () => {
+      try {
+        logger.log("\nSIGINT received. Attempting graceful shutdown...");
+        await orchestrator?.stop();
+        logger.log("Orchestrator stopped, exiting now.");
+        process.exit(0);
+      } catch (err) {
+        logger.error("Error stopping orchestrator:", err);
+        process.exit(1);
+      }
+    })();
+  });
+  return {
+    logger,
+    orchestrator
+  };
+}, "getContextFromConfig");
+async function runCLI() {
+  const y = yargs(hideBin(process.argv));
+  const argv = y.usage(`
+\u{1F680} XL1 Node CLI (${version})
+${XL1LogoColorizedAscii}
+Run various components of the XL1 ecosystem.
+
+Usage:
+$0 <command> [options]`).parserConfiguration({
+    "dot-notation": true
+  }).env("XL1").scriptName("xl1").config().version(version).middleware((argv2) => {
+    try {
+      config = ConfigSchema.parse(argv2);
+    } catch (err) {
+      if (err instanceof ZodError) {
+        for (const issue of err.errors) {
+          console.error(`${issue.path.join(".")} \u2192 ${issue.message}`);
+        }
+      }
+      throw new Error("Invalid configuration");
+    }
+  }).options(optionsFromZodSchema(ConfigSchema.shape)).wrap(y.terminalWidth()).command("api", "Run a XL1 API Node", (yargs2) => {
+    return yargs2.command("$0", "Run a XL1 API Node", () => {
+    }, () => {
+      const context = getContextFromConfig(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
+      });
+    });
+  }).command("$0", "Run a full XL1 Node", () => {
+  }, async () => {
+    const context = getContextFromConfig(config);
+    runApi({
+      ...context,
+      config
+    });
+    await waitForHostPort("localhost", config.api.port);
+    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
+  });
+  await runCLI();
+}, "start");
+export {
+  Actor,
+  BalanceActor,
+  ChainHeadUpdateActor,
+  LoggerStatusReporter,
+  Orchestrator,
+  ProducerActor,
+  RuntimeStatusMonitor,
+  ValidatorActor,
+  canUseEvmProvider,
+  initAccount,
+  initBalanceService,
+  initBlockProducer,
+  initBlockRewardService,
+  initChainIterator,
+  initChainService,
+  initElectionService,
+  initEvmProvider,
+  initHead,
+  initHealthEndpoints,
+  initPendingTransactions,
+  initServices,
+  initStakeIntentService,
+  initValidator,
+  runCLI,
+  start
+};
+//# sourceMappingURL=index.mjs.map