@xyo-network/xl1-cli 1.6.2

package/build/node/xl1.mjs

@@ -0,0 +1,1474 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/initEnv.ts
+import dotenv from "dotenv";
+var initEnv = /* @__PURE__ */ __name(() => {
+  dotenv.config();
+  if (process.env.ENV_FILE !== void 0) {
+    dotenv.config({
+      path: process.env.ENV_FILE,
+      override: true
+    });
+  }
+}, "initEnv");
+
+// 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 { BaseEmitter } from "@xylabs/events";
+import { forget } from "@xylabs/forget";
+import { IdLogger } from "@xylabs/logger";
+import { span, spanAsync } from "@xylabs/telemetry";
+var Actor = class extends BaseEmitter {
+  static {
+    __name(this, "Actor");
+  }
+  _timers = /* @__PURE__ */ new Map();
+  _active = false;
+  _displayName;
+  _id;
+  constructor(id, displayName = "Actor", params) {
+    const logger = params.logger ?? new IdLogger(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;
+  running = false;
+  /**
+  * 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) {
+      console.log("[Orchestrator] Already started.");
+      return;
+    }
+    console.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) {
+      console.log("[Orchestrator] Already stopped.");
+      return;
+    }
+    console.log("[Orchestrator] Stopping...");
+    for (const actor of this.actors) {
+      await actor.stop();
+    }
+    this.running = false;
+    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle);
+    console.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 async create(params) {
+    await Promise.resolve();
+    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(assertEx3(params.producer?.address, () => "Missing producer in params"), "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 async create(params) {
+    await Promise.resolve();
+    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 (!BaseBlockProducerService.RedeclareIntent) 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 ${process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS} 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 = isDefined(process.env.XYO_PRODUCER_MIN_STAKE) ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE) : 1n;
+    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/health/initHealthEndpoints.ts
+import http from "http";
+import { isDefined as isDefined2, isEmptyString } 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 = 8080, statusMonitor) => {
+  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, () => {
+    console.log(`Health server running on http://localhost:${port}`);
+    console.log(" - /healthz");
+    console.log(" - /livez");
+    console.log(" - /readyz");
+  });
+  return server;
+}, "createHealthServer");
+var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
+  const healthCheckEnvVarPort = process.env.XYO_PRODUCER_HEALTH_CHECK_PORT;
+  if (isDefined2(healthCheckEnvVarPort) && !isEmptyString(healthCheckEnvVarPort)) {
+    const healthCheckPort = Number.parseInt(healthCheckEnvVarPort, 10);
+    return createHealthServer(healthCheckPort, params.statusReporter);
+  }
+}, "initHealthEndpoints");
+
+// src/orchestration/initServices.ts
+import { assertEx as assertEx16 } from "@xylabs/assert";
+import { Base } from "@xylabs/base";
+import { asAddress as asAddress2 } from "@xylabs/hex";
+import { isDefined as isDefined5 } 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 { LmdbArchivist, LmdbArchivistConfigSchema } from "@xyo-network/archivist-lmdb";
+
+// src/orchestration/store/getStoreDirectory.ts
+import Path from "path";
+var STORAGE_ROOT = process.env.STORAGE_ROOT ?? Path.join(process.cwd(), ".store");
+var getStoreDirectory = /* @__PURE__ */ __name((name, kind) => {
+  return kind === void 0 ? Path.join(STORAGE_ROOT, name) : Path.join(STORAGE_ROOT, kind, name);
+}, "getStoreDirectory");
+
+// src/orchestration/archivists/lib/localPersistentArchivist.ts
+var getLocalPersistentArchivist = /* @__PURE__ */ __name((dbName, storeName, kind = "lmdb") => {
+  switch (kind) {
+    case "lmdb": {
+      return LmdbArchivist.create({
+        account: "random",
+        config: {
+          clearStoreOnStart: false,
+          dbName,
+          location: getStoreDirectory(dbName, "lmdb"),
+          schema: LmdbArchivistConfigSchema,
+          storeName
+        }
+      });
+    }
+  }
+}, "getLocalPersistentArchivist");
+
+// src/orchestration/archivists/ChainFinalized/local.ts
+var mutex = new Mutex2();
+var singleton;
+var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton;
+    singleton = await getLocalPersistentArchivist("chain", "finalized");
+    return singleton;
+  });
+}, "initLocalChainFinalizedArchivist");
+
+// src/orchestration/archivists/ChainFinalized/remote.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { initBridge, initBridgedArchivistModule } from "@xyo-network/chain-orchestration";
+import { Mutex as Mutex3 } from "async-mutex";
+var nodeUrl = process.env.XYO_CHAIN_ARCHIVIST_NODE_URL ?? "http://localhost:8080";
+var mutex2 = new Mutex3();
+var singleton2;
+var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex2.runExclusive(async () => {
+    if (singleton2) return singleton2;
+    const bridge = await initBridge(nodeUrl);
+    singleton2 = await initBridgedArchivistModule({
+      bridge,
+      moduleName: "XYOChain:Chain:Finalized"
+    });
+    return assertEx4(singleton2, () => "Error: RemoteChainFinalizedArchivist failed to initialize");
+  });
+}, "initRemoteChainFinalizedArchivist");
+
+// src/orchestration/archivists/ChainFinalized/archivist.ts
+var mutex3 = new Mutex4();
+var singleton3;
+async function initChainFinalizedArchivist(traceProvider) {
+  return await mutex3.runExclusive(async () => {
+    if (singleton3) return singleton3;
+    const [remote, local] = await Promise.all([
+      startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist()),
+      startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist())
+    ]);
+    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 assertEx6 } 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 assertEx5 } from "@xylabs/assert";
+import { initBridge as initBridge2, initBridgedArchivistModule as initBridgedArchivistModule2 } from "@xyo-network/chain-orchestration";
+import { Mutex as Mutex5 } from "async-mutex";
+var nodeUrl2 = process.env.XYO_CHAIN_ARCHIVIST_NODE_URL ?? "http://localhost:8080";
+var mutex4 = new Mutex5();
+var singleton4;
+var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex4.runExclusive(async () => {
+    if (singleton4) return singleton4;
+    const bridge = await initBridge2(nodeUrl2);
+    singleton4 = await initBridgedArchivistModule2({
+      bridge,
+      moduleName: "XYOChain:Chain:Submissions"
+    });
+    return assertEx5(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 () => {
+  return await mutex5.runExclusive(async () => {
+    if (singleton5) return singleton5;
+    const remote = await startupSpanAsync2("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist());
+    singleton5 = remote;
+    return assertEx6(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 assertEx7 } from "@xylabs/assert";
+import { initBridge as initBridge3, initBridgedArchivistModule as initBridgedArchivistModule3 } from "@xyo-network/chain-orchestration";
+import { Mutex as Mutex8 } from "async-mutex";
+var bridgeUrl = process.env.XYO_PENDING_ARCHIVIST_NODE_URL ?? "http://localhost:8080";
+var mutex7 = new Mutex8();
+var singleton7;
+var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex7.runExclusive(async () => {
+    if (singleton7) return singleton7;
+    const bridge = await initBridge3(bridgeUrl);
+    singleton7 = await initBridgedArchivistModule3({
+      bridge,
+      moduleName: "XYOChain:Pending:PendingTransactions"
+    });
+    return assertEx7(singleton7, () => "Error: RemotePendingBundledTransactionsArchivist is undefined");
+  });
+}, "initRemotePendingTransactionsArchivist");
+
+// src/orchestration/archivists/PendingTransactions/archivist.ts
+var mutex8 = new Mutex9();
+var singleton8;
+async function initPendingBundledTransactionsArchivist(_) {
+  return await mutex8.runExclusive(async () => {
+    if (singleton8) return singleton8;
+    const remote = await startupSpanAsync3("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist());
+    const local = await startupSpanAsync3("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist());
+    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;
+  });
+}
+__name(initPendingBundledTransactionsArchivist, "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(_traceProvider) {
+  return await mutex10.runExclusive(async () => {
+    if (singleton10) return singleton10;
+    const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist());
+    singleton10 = local;
+    return singleton10;
+  });
+}
+__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
+
+// src/orchestration/archivists/StakeIntentState/archivist.ts
+import { assertEx as assertEx9 } 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 assertEx8 } from "@xylabs/assert";
+import { Mutex as Mutex12 } from "async-mutex";
+var mutex11 = new Mutex12();
+var singleton11;
+var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex11.runExclusive(async () => {
+    if (singleton11) return singleton11;
+    console.log("[InitServices:LocalStakeIntentStateArchivist:Initializing]");
+    singleton11 = await getLocalPersistentArchivist("stakeIntent", "state");
+    console.log("[InitServices:LocalStakeIntentStateArchivist:Initialized]");
+    return assertEx8(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 () => {
+  return await mutex12.runExclusive(async () => {
+    if (singleton12) return singleton12;
+    const local = await startupSpanAsync5("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist());
+    singleton12 = local;
+    return assertEx9(singleton12, () => "Error: StakeIntentStateArchivist is undefined");
+  });
+}, "initStakeIntentStateArchivist");
+
+// src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
+import { isDefined as isDefined4 } 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 isDefined3 } from "@xylabs/typeof";
+import { Mutex as Mutex14 } from "async-mutex";
+
+// src/orchestration/map/localPersistentMap.ts
+import { rm as rm2 } from "fs/promises";
+
+// src/orchestration/map/driver/lmdb/SynchronousLmdbMap.ts
+import { creatable } from "@xylabs/creatable";
+import { BaseService } from "@xyo-network/chain-services";
+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 BaseService {
+  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 getLocalPersistentMap = /* @__PURE__ */ __name(async (dbName, storeName, kind = "lmdb") => {
+  switch (kind) {
+    case "lmdb": {
+      const location = getStoreDirectory(dbName, "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 () => {
+  return await mutex13.runExclusive(async () => {
+    if (isDefined3(singleton13)) return singleton13;
+    singleton13 = await getLocalPersistentMap("balance", "summary");
+    return singleton13;
+  });
+}, "initLocalBalanceSummaryMap");
+
+// src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
+var mutex14 = new Mutex15();
+var singleton14;
+async function initBalanceSummaryMap(_traceProvider) {
+  return await mutex14.runExclusive(async () => {
+    if (isDefined4(singleton14)) return singleton14;
+    const local = await startupSpanAsync6("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap());
+    singleton14 = local;
+    return singleton14;
+  });
+}
+__name(initBalanceSummaryMap, "initBalanceSummaryMap");
+
+// src/orchestration/services/implementation/account.ts
+import { isUndefined as isUndefined2 } 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 () => {
+  if (accountServiceSingleton) return accountServiceSingleton;
+  let walletPhrase = process.env.XYO_WALLET_MNEMONIC;
+  if (isUndefined2(walletPhrase)) {
+    console.log("No wallet mnemonic specified!");
+    const randomMnemonic = HDWallet.generateMnemonic();
+    console.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 assertEx14 } from "@xylabs/assert";
+import { asAddress } from "@xylabs/hex";
+import { EvmChainService } from "@xyo-network/chain-services";
+import { Wallet } from "ethers/wallet";
+
+// src/orchestration/services/implementation/evm/initEvmProvider.ts
+import { assertEx as assertEx13 } from "@xylabs/assert";
+
+// src/orchestration/services/implementation/evm/initGanacheProvider.ts
+import { assertEx as assertEx11 } from "@xylabs/assert";
+import { JsonRpcProvider } from "ethers/providers";
+
+// src/orchestration/services/implementation/evm/initChainId.ts
+import { assertEx as assertEx10 } from "@xylabs/assert";
+import { hexFrom, isHex } from "@xylabs/hex";
+var canUseChainId = /* @__PURE__ */ __name(() => {
+  return process.env.XYO_JSON_RPC_NETWORK !== void 0;
+}, "canUseChainId");
+var getChainId = /* @__PURE__ */ __name(() => {
+  const chainId = assertEx10(process.env.XYO_JSON_RPC_NETWORK, () => "Missing XYO_JSON_RPC_NETWORK ENV VAR");
+  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/initGanacheProvider.ts
+var initJsonRpcProvider = /* @__PURE__ */ __name(() => {
+  const config2 = getJsonRpcProviderConfig();
+  return Promise.resolve(new JsonRpcProvider(...config2));
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider = /* @__PURE__ */ __name(() => {
+  return canUseChainId() && process.env.XYO_JSON_RPC_URL !== void 0;
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name(() => {
+  const jsonRpcUrl = assertEx11(process.env.XYO_JSON_RPC_URL, () => "Missing XYO_JSON_RPC_URL ENV VAR");
+  return [
+    jsonRpcUrl,
+    getChainId()
+  ];
+}, "getJsonRpcProviderConfig");
+
+// src/orchestration/services/implementation/evm/initInfuraProvider.ts
+import { assertEx as assertEx12 } from "@xylabs/assert";
+import { InfuraProvider } from "ethers/providers";
+var instance;
+var initInfuraProvider = /* @__PURE__ */ __name(() => {
+  if (instance) return instance;
+  const config2 = getInfuraProviderConfig();
+  instance = Promise.resolve(new InfuraProvider(...config2));
+  return instance;
+}, "initInfuraProvider");
+var canUseInfuraProvider = /* @__PURE__ */ __name(() => {
+  return canUseChainId() && process.env.INFURA_PROJECT_ID != void 0 && process.env.INFURA_PROJECT_SECRET != void 0;
+}, "canUseInfuraProvider");
+var getInfuraProviderConfig = /* @__PURE__ */ __name(() => {
+  const projectId = assertEx12(process.env.INFURA_PROJECT_ID, () => "Missing INFURA_PROJECT_ID ENV VAR");
+  const projectSecret = assertEx12(process.env.INFURA_PROJECT_SECRET, () => "Missing INFURA_PROJECT_SECRET ENV VAR");
+  return [
+    getChainId(),
+    projectId,
+    projectSecret
+  ];
+}, "getInfuraProviderConfig");
+
+// src/orchestration/services/implementation/evm/initEvmProvider.ts
+var provider;
+var initEvmProvider = /* @__PURE__ */ __name(async () => {
+  if (provider) return provider;
+  if (canUseInfuraProvider()) {
+    provider = initInfuraProvider();
+  } else if (canUseJsonRpcProvider()) {
+    provider = initJsonRpcProvider();
+  }
+  return assertEx13(await provider, () => "Error: No provider available");
+}, "initEvmProvider");
+var canUseEvmProvider = /* @__PURE__ */ __name(() => {
+  return canUseInfuraProvider() || canUseJsonRpcProvider();
+}, "canUseEvmProvider");
+
+// src/orchestration/services/implementation/chain/evm.ts
+var chainStakeServiceSingleton;
+var canUseEvmContractChainService = /* @__PURE__ */ __name(() => {
+  return process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS !== void 0 && canUseEvmProvider();
+}, "canUseEvmContractChainService");
+var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, traceProvider, meterProvider, logger }) => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton;
+  const emvStakingContractAddress = assertEx14(process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS, () => "Error: XYO_EVM_STAKING_CONTRACT_ADDRESS is required");
+  const id = assertEx14(asAddress(emvStakingContractAddress), () => "Error: XYO_EVM_STAKING_CONTRACT_ADDRESS is invalid");
+  const provider2 = assertEx14(await initEvmProvider());
+  const privateKey = assertEx14(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 }) => init({
+  name: "ChainService",
+  account
+}), "initChainService");
+var init = /* @__PURE__ */ __name(({ account, traceProvider, meterProvider, logger }) => {
+  if (chainStakeServiceSingleton2) return chainStakeServiceSingleton2;
+  chainStakeServiceSingleton2 = canUseEvmContractChainService() ? initEvmContractChainService({
+    name: "ChainStakeService",
+    account,
+    traceProvider,
+    meterProvider,
+    logger
+  }) : MemoryChainService.create({});
+  return chainStakeServiceSingleton2;
+}, "init");
+
+// src/orchestration/services/implementation/head.ts
+import { delay } from "@xylabs/delay";
+import { ZERO_ADDRESS } 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_ADDRESS, 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 assertEx15 } from "@xylabs/assert";
+import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-services";
+var rewardServiceSingleton;
+var initBlockRewardService = /* @__PURE__ */ __name((params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  rewardServiceSingleton = canUseEvmBlockRewardService() ? 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(() => canUseEvmProvider(), "canUseEvmBlockRewardService");
+var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
+  if (rewardServiceSingleton) return rewardServiceSingleton;
+  const { account: paramsAccount } = params;
+  const account = assertEx15(paramsAccount, () => "Error: Account is required");
+  const provider2 = assertEx15(await initEvmProvider());
+  const evmBlockRewardServiceParams = {
+    ...params,
+    provider: provider2,
+    account
+  };
+  rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams);
+  return rewardServiceSingleton;
+}, "initEvmBlockRewardService");
+
+// 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 isDefined5(value.start) && typeof value.start === "function";
+}, "isStartable");
+var initServices = /* @__PURE__ */ __name(async (logger) => {
+  Base.defaultLogger = logger ?? console;
+  const statusReporter = new RuntimeStatusMonitor(logger ?? console);
+  statusReporter.onGlobalTransition({
+    to: "started"
+  }, () => {
+    Base.defaultLogger?.log("All services started.");
+  });
+  statusReporter.onGlobalTransition({
+    to: "error"
+  }, () => {
+    Base.defaultLogger?.error("Producer encountered an unhandled error!");
+    process.exit(1);
+  });
+  await startupSpanAsync7("initHealthEndpoints", () => initHealthEndpoints({
+    statusReporter
+  }));
+  const [{ traceProvider, meterProvider }, account] = await Promise.all([
+    startupSpanAsync7("initTelemetry", () => initTelemetry(telemetryConfig)),
+    startupSpanAsync7("initAccount", () => initAccount())
+  ]);
+  const [chainArchivist, [pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite], rejectedTransactionsArchivist, chainSubmissionsArchivistWrite, stakeIntentStateArchivist, chainService, balanceSummaryMap] = await Promise.all([
+    startupSpanAsync7("ChainFinalizedArchivist", () => initChainFinalizedArchivist(traceProvider)),
+    startupSpanAsync7("PendingBundledTransactionsArchivist", () => initPendingBundledTransactionsArchivist(traceProvider)),
+    startupSpanAsync7("RejectedTransactionsArchivist", () => initRejectedTransactionsArchivist(traceProvider)),
+    startupSpanAsync7("ChainSubmissionsArchivist", () => initChainSubmissionsArchivist()),
+    startupSpanAsync7("StakeIntentStateArchivist", () => initStakeIntentStateArchivist()),
+    startupSpanAsync7("ChainService", () => initChainService({
+      account,
+      name: "ChainService"
+    })),
+    startupSpanAsync7("BalanceSummaryMap", () => initBalanceSummaryMap(traceProvider))
+  ]);
+  const chainId = chainService.chainId;
+  const chainContractViewer = chainService;
+  const chainStakeViewer = chainService;
+  const chainStaker = chainService;
+  const head = await startupSpanAsync7("initHead", () => initHead({
+    account,
+    chainArchivist,
+    chainSubmissionsArchivistWrite
+  }));
+  const [pendingTransactionsService, rewardService, chainIterator, balanceService] = await Promise.all([
+    startupSpanAsync7("PendingTransactions", () => initPendingTransactions({
+      name: "PendingTransactionsService",
+      chainArchivist,
+      chainId,
+      meterProvider,
+      pendingBundledTransactionsArchivist,
+      rejectedTransactionsArchivist,
+      traceProvider,
+      statusReporter
+    })),
+    startupSpanAsync7("RewardService", () => initBlockRewardService({
+      name: "RewardService",
+      account,
+      chainService,
+      traceProvider,
+      statusReporter
+    })),
+    startupSpanAsync7("ChainIterator", () => initChainIterator({
+      name: "ChainIterator",
+      traceProvider,
+      chainArchivist,
+      head,
+      statusReporter
+    })),
+    startupSpanAsync7("BalanceService", () => initBalanceService({
+      name: "BalanceService",
+      chainArchivist,
+      summaryRepository: balanceSummaryRepositoryFromMap(balanceSummaryMap)
+    }))
+  ]);
+  const stakeIntentService = await startupSpanAsync7("StakeIntentService", () => initStakeIntentService({
+    name: "StakeIntentService",
+    chainArchivist,
+    chainIterator,
+    chainStakeViewer,
+    logger: console,
+    stakeIntentStateArchivist,
+    traceProvider,
+    statusReporter
+  }));
+  const electionService = await startupSpanAsync7("ElectionService", () => initElectionService({
+    name: "ElectionService",
+    traceProvider,
+    chainIterator,
+    chainStakeViewer,
+    stakeIntentService,
+    statusReporter
+  }));
+  const validatorParams = {
+    name: "Validator",
+    account,
+    chainId,
+    pendingBundledTransactionsArchivist,
+    chainArchivist,
+    electionService,
+    rewardService,
+    stakeIntentService,
+    traceProvider,
+    validateHydratedBlockState
+  };
+  const rewardAddress = isDefined5(process.env.XYO_BLOCK_REWARD_ADDRESS) ? assertEx16(asAddress2(process.env.XYO_BLOCK_REWARD_ADDRESS), () => "Invalid block reward address provided") : account.address;
+  const producerParams = {
+    ...validatorParams,
+    name: "Producer",
+    balanceService,
+    chainArchivist,
+    pendingBundledTransactionsArchivist,
+    pendingTransactionsService,
+    rejectedTransactionsArchivist,
+    rewardAddress
+  };
+  const producer = await startupSpanAsync7("Producer", () => initBlockProducer(producerParams));
+  const result = {
+    account,
+    balanceService,
+    chainArchivist,
+    chainContractViewer,
+    chainIterator,
+    chainStaker,
+    chainStakeViewer,
+    chainSubmissionsArchivistWrite,
+    electionService,
+    pendingBundledTransactionsArchivistWrite,
+    pendingTransactionsService,
+    producer,
+    rewardService,
+    stakeIntentService
+  };
+  Base.defaultLogger?.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 net from "net";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/commands/api/runApi.ts
+import { getServer } from "@xyo-network/chain-api";
+import { config } from "dotenv";
+function runApi() {
+  config();
+  void getServer();
+}
+__name(runApi, "runApi");
+
+// src/commands/producer/runProducer.ts
+var runProducer = /* @__PURE__ */ __name(async (orchestrator) => {
+  console.log("Services: Initializing...");
+  const services = await initServices();
+  console.log("Services: Initialized");
+  const chainHeadUpdate = await ChainHeadUpdateActor.create(services);
+  const producer = await ProducerActor.create(services);
+  const balances = await BalanceActor.create(services);
+  const actors = [
+    chainHeadUpdate,
+    producer,
+    balances
+  ];
+  for (const actor of actors) {
+    await orchestrator.registerActor(actor);
+  }
+  await orchestrator.start();
+}, "runProducer");
+
+// src/commands/validator/runValidator.ts
+var runValidator = /* @__PURE__ */ __name(async (orchestrator) => {
+  const myActor = new Actor("Validator", "Validator", {});
+  await orchestrator.registerActor(myActor);
+  await orchestrator.start();
+}, "runValidator");
+
+// src/runCLI.ts
+function waitForPort(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();
+  });
+}
+__name(waitForPort, "waitForPort");
+async function runCLI(orchestrator) {
+  async function validateTransaction() {
+    console.log("Validating transaction...");
+    await Promise.resolve();
+  }
+  __name(validateTransaction, "validateTransaction");
+  async function submitTransaction() {
+    console.log("Submitting transaction...");
+    await Promise.resolve();
+  }
+  __name(submitTransaction, "submitTransaction");
+  async function checkBalance() {
+    console.log("Checking account balance...");
+    await Promise.resolve();
+  }
+  __name(checkBalance, "checkBalance");
+  const argv = yargs(hideBin(process.argv)).command("validator", "Run the XL1 validator", (yargs2) => {
+    return yargs2.command("$0", "Run as a XL1 validator node", () => {
+    }, () => runValidator(orchestrator));
+  }).command("producer", "Run the XL1 producer", (yargs2) => {
+    return yargs2.command("$0", "Run as a XL1 producer node", () => {
+    }, () => runProducer(orchestrator));
+  }).command("client", "Client-related operations", (yargs2) => {
+    return yargs2.command("transaction", "Transaction-related operations", (yargs3) => {
+      return yargs3.command("validate", "Validate a transaction", () => {
+      }, validateTransaction).command("submit", "Submit a transaction", () => {
+      }, submitTransaction);
+    });
+  }).command("api", "Run as a api node", (yargs2) => {
+    return yargs2.command("$0", "Run as a api node", () => {
+    }, () => runApi()).command("run", "Run as a api node", () => {
+    }, () => runApi());
+  }).command("$0", "Run a full XL1 deployment", (yargs2) => {
+    return yargs2.command("$0", "Start the API and a producer", () => {
+    }, async () => {
+      runApi();
+      await waitForPort("localhost", 8080);
+      await runProducer(orchestrator);
+    });
+  }).command("account", "Account-related operations", (yargs2) => {
+    return yargs2.command("balance", "Check account balance", () => {
+    }, checkBalance);
+  }).help().alias("help", "h").env("XL1").argv;
+  await argv;
+}
+__name(runCLI, "runCLI");
+
+// src/start.ts
+var start = /* @__PURE__ */ __name(async () => {
+  initEnv();
+  const orchestrator = new Orchestrator();
+  process.on("SIGINT", () => {
+    void (async () => {
+      try {
+        console.log("\nSIGINT received. Attempting graceful shutdown...");
+        await orchestrator?.stop();
+        console.log("Orchestrator stopped, exiting now.");
+        process.exit(0);
+      } catch (err) {
+        console.error("Error stopping orchestrator:", err);
+        process.exit(1);
+      }
+    })();
+  });
+  await runCLI(orchestrator);
+}, "start");
+
+// src/xl1.ts
+start().catch((err) => {
+  console.error("An error occurred during startup:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=xl1.mjs.map