@xyo-network/xl1-cli-lib 1.17.0 → 1.17.2

package/dist/node/xl1.mjs

@@ -5,7 +5,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { config } from "dotenv";
 
 // src/runCLI.ts
-import { deepMerge, isDefined as isDefined18 } from "@xylabs/sdk-js";
+import { deepMerge, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { Orchestrator } from "@xyo-network/chain-orchestration";
+import { runProducer } from "@xyo-network/chain-producer";
 import { ConfigZod } from "@xyo-network/xl1-protocol-sdk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
@@ -32,1372 +34,6 @@ function runMempool(context) {
 }
 __name(runMempool, "runMempool");
 
-// src/commands/producer/runProducer.ts
-import { exists, isDefined as isDefined15 } from "@xylabs/sdk-js";
-
-// src/orchestration/actor/implementation/BalanceActor.ts
-import { assertEx } from "@xylabs/sdk-js";
-import { Mutex } from "async-mutex";
-
-// src/orchestration/actor/model/Actor.ts
-import { Base, delay, IdLogger } from "@xylabs/sdk-js";
-import { span, spanRootAsync } from "@xylabs/telemetry";
-import { Semaphore } from "async-mutex";
-var Actor = class extends Base {
-  static {
-    __name(this, "Actor");
-  }
-  _intervals = /* @__PURE__ */ new Map();
-  _semaphores = /* @__PURE__ */ new Map();
-  _timeouts = /* @__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.params.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;
-    }
-    let running = false;
-    this._semaphores.set(timerName, new Semaphore(1));
-    const timeoutId = setTimeout(() => {
-      const intervalId = setInterval(() => {
-        const semaphore = this._semaphores.get(timerName);
-        if (!this._active || !this._intervals.has(timerName) || !semaphore || running) return;
-        if (semaphore.isLocked()) {
-          this.logger?.warn(`Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`);
-          return;
-        }
-        semaphore.acquire().then(([, release]) => {
-          const startTime = Date.now();
-          running = true;
-          callback().then(() => {
-            const duration = Date.now() - startTime;
-            if (duration > periodMs) {
-              this.logger?.warn(`Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`);
-            } else if (duration > 5e3) {
-              this.logger?.warn(`Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`);
-            }
-          }).catch((error) => {
-            this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`);
-          }).finally(() => {
-            release();
-            running = false;
-          });
-        }).catch((error) => {
-          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`);
-        });
-      }, periodMs);
-      this._intervals.set(timerName, intervalId);
-    }, dueTimeMs);
-    this._timeouts.set(timerName, timeoutId);
-    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 spanRootAsync(`${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...");
-    await Promise.all([
-      ...this._semaphores.values()
-    ].map(async (semaphore) => {
-      while (semaphore.isLocked()) {
-        this.logger?.log("Waiting for running timer task to complete...");
-        await delay(500);
-      }
-      await semaphore.acquire();
-    }));
-    this._semaphores.clear();
-    for (const [, timeoutRef] of this._timeouts.entries()) {
-      clearTimeout(timeoutRef);
-    }
-    this._timeouts.clear();
-    for (const [, intervalRef] of this._intervals.entries()) {
-      clearInterval(intervalRef);
-    }
-    this._intervals.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.balance, () => "balanceService not set");
-  }
-  get blockViewer() {
-    return assertEx(this.params.blockViewer, () => "blockViewer not set");
-  }
-  static create(params) {
-    return new _BalanceActor(params);
-  }
-  async start() {
-    await super.start();
-    this.registerTimer(
-      "BalanceTimer",
-      async () => {
-        await this.updateBalance();
-      },
-      1e3,
-      1e4
-      /* 1000 */
-    );
-  }
-  async updateBalance() {
-    if (this._updateMutex.isLocked()) return;
-    await this._updateMutex.runExclusive(async () => {
-      const head = await this.blockViewer.currentBlockHash();
-      await this.balanceService.accountsBalances([], head);
-    });
-  }
-};
-
-// src/orchestration/actor/implementation/ProducerActor.ts
-import { assertEx as assertEx2, isDefined, isUndefined, toHex } from "@xylabs/sdk-js";
-import { createDeclarationIntent } from "@xyo-network/chain-protocol";
-import { BaseBlockProducerService } from "@xyo-network/chain-services";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { PayloadBundleSchema } from "@xyo-network/payload-model";
-import { asXL1BlockNumber } from "@xyo-network/xl1-protocol";
-import { buildTransaction, flattenHydratedBlock, flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex2 } from "async-mutex";
-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;
-  _metricAttributes;
-  _producerActorBlockProductionAttempts;
-  _producerActorBlockProductionChecks;
-  _producerActorBlocksProduced;
-  _producerActorBlocksPublished;
-  _produceBlockMutex = new Mutex2();
-  constructor(params) {
-    super(params.producer.address, "Producer", params);
-    this._metricAttributes = {
-      address: this.account.address.toString()
-    };
-    this._producerActorBlockProductionChecks = this.meter?.createCounter("producer_actor_block_production_checks", {
-      description: "Number of block production checks"
-    });
-    this._producerActorBlockProductionAttempts = this.meter?.createCounter("producer_actor_block_production_attempts", {
-      description: "Number of block production attempts"
-    });
-    this._producerActorBlocksProduced = this.meter?.createCounter("producer_actor_blocks_produced", {
-      description: "Number of blocks produced"
-    });
-    this._producerActorBlocksPublished = this.meter?.createCounter("producer_actor_blocks_published", {
-      description: "Number of blocks published"
-    });
-  }
-  get account() {
-    return assertEx2(this.params.account, () => "account not set");
-  }
-  get balanceService() {
-    return assertEx2(this.params.balance, () => "balanceService not set");
-  }
-  get blockViewer() {
-    return assertEx2(this.params.blockViewer, () => "blockViewer not set");
-  }
-  get chainStakeViewer() {
-    return assertEx2(this.params.chainStakeViewer, () => "chainStakeViewer not set");
-  }
-  get chainSubmissionsArchivistWrite() {
-    return assertEx2(this.params.chainSubmissionsArchivistWrite, () => "chainSubmissionsArchivistWrite not set");
-  }
-  get pendingBundledTransactionsArchivistWrite() {
-    return assertEx2(this.params.pendingBundledTransactionsArchivistWrite, () => "pendingBundledTransactionsArchivistWrite not set");
-  }
-  get producer() {
-    return assertEx2(this.params.producer, () => "producer not set");
-  }
-  get stakeIntentService() {
-    return assertEx2(this.params.stakeIntent, () => "stakeIntentService not set");
-  }
-  static create(params) {
-    return new _ProducerActor(params);
-  }
-  async start() {
-    await super.start();
-    this.registerTimer(
-      "BlockProductionTimer",
-      async () => {
-        await this.produceBlock();
-      },
-      2e3,
-      1500
-      /* 500 */
-    );
-    if (SHOULD_REGISTER_REDECLARATION_INTENT_TIMER) {
-      this.registerTimer("ProducerRedeclarationTimer", async () => {
-        await this.redeclareIntent();
-      }, TEN_MINUTES, 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 produceBlock() {
-    this._producerActorBlockProductionChecks?.add(1, this._metricAttributes);
-    await this.spanAsync("produceBlock", async () => {
-      if (this._produceBlockMutex.isLocked()) {
-        this.logger?.log("Skipping block production, previous production still in progress");
-        return;
-      }
-      await this._produceBlockMutex.runExclusive(async () => {
-        const headStart = Date.now();
-        const head = (await this.blockViewer.currentBlock())[0];
-        const headDuration = Date.now() - headStart;
-        if (headDuration > 500) this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex(head._hash)}`);
-        const headHash = head._hash;
-        if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
-          this.logger?.log("Block already produced:", `0x${toHex(this._lastProducedBlock[0].block)}`, this._lastProducedBlock[0].block);
-        } else {
-          this._producerActorBlockProductionAttempts?.add(1, this._metricAttributes);
-          const nextStart = Date.now();
-          const nextBlock = await this.producer.next(head);
-          const nextDuration = Date.now() - nextStart;
-          if (nextDuration > 1e3) this.logger?.warn(`[Slow] Generated next block in ${nextDuration}ms, block: ${nextBlock?.[0]._hash}`);
-          if (nextBlock) {
-            const displayBlockNumber = `0x${toHex(nextBlock[0].block)}`;
-            this.logger?.log("Produced block:", displayBlockNumber);
-            this._producerActorBlocksProduced?.add(1, this._metricAttributes);
-            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
-            this.logger?.log("Published block:", displayBlockNumber, nextBlock[0].block);
-            this._producerActorBlocksPublished?.add(1, this._metricAttributes);
-            this._lastProducedBlock = nextBlock;
-          }
-        }
-      });
-    });
-  }
-  async redeclareIntent() {
-    await this.spanAsync("redeclareIntent", async () => {
-      if (this.params.config.producer.disableIntentRedeclaration) return;
-      const head = (await this.blockViewer.currentBlock())[0];
-      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;
-    });
-  }
-  async submitRedeclarationIntent(currentBlock, redeclarationIntent) {
-    this.logger?.log("Submitting redeclaration intent for producer:", this.account.address);
-    const tx = await buildTransaction(await this.chainStakeViewer.chainId(), [
-      redeclarationIntent
-    ], [], this.account, currentBlock, asXL1BlockNumber(currentBlock + 1e3, true));
-    const payloads = flattenHydratedTransaction(tx);
-    const root = tx[0]._hash;
-    const payloadBundle = new PayloadBuilder({
-      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.accountsBalances([
-        this.account.address
-      ], head);
-      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.activeByStaked(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 } from "@xylabs/sdk-js";
-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: config2, logger, statusReporter } = params;
-  const { healthCheckPort } = config2.producer;
-  return isDefined2(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
-}, "initHealthEndpoints");
-
-// src/orchestration/initServices.ts
-import { asAddress as asAddress2, assertEx as assertEx15, isDefined as isDefined14 } from "@xylabs/sdk-js";
-import { initElectionService, initProducerAccount, initStakeIntentService } from "@xyo-network/chain-orchestration";
-import { initTelemetry } from "@xyo-network/chain-telemetry";
-import { startupSpanAsync as startupSpanAsync7 } from "@xyo-network/chain-utils";
-import { validateHydratedBlockState } from "@xyo-network/chain-validation";
-import { CompletedStepRewardAddressValidatorFactory, DerivedReceiveAddressValidatorFactory, SelfSignerValidator, TransactionTransfersValidatorFactory } from "@xyo-network/xl1-validation";
-
-// src/orchestration/archivists/lib/localPersistentArchivist.ts
-import { rm } from "fs/promises";
-import Path from "path";
-import { LmdbArchivist, LmdbArchivistConfigSchema } from "@xyo-network/archivist-lmdb";
-import { getStoreDirectory } from "@xyo-network/chain-protocol";
-var DEFAULT_STORAGE_ROOT = Path.join(process.cwd(), ".store");
-var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeName, storageRoot, kind = "lmdb") => {
-  switch (kind) {
-    case "lmdb": {
-      const root = storageRoot ?? DEFAULT_STORAGE_ROOT;
-      return LmdbArchivist.create({
-        account: "random",
-        config: {
-          name,
-          clearStoreOnStart: false,
-          dbName,
-          location: getStoreDirectory(dbName, root, "lmdb"),
-          schema: LmdbArchivistConfigSchema,
-          storeName
-        }
-      });
-    }
-  }
-}, "getLocalPersistentArchivist");
-
-// src/orchestration/archivists/ChainSubmissions/archivist.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
-import { startupSpanAsync } from "@xyo-network/chain-utils";
-import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex4 } from "async-mutex";
-
-// src/orchestration/archivists/ChainSubmissions/remote.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
-import { initBridge, initBridgedArchivistModule } from "@xyo-network/chain-orchestration";
-import { getUrl } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex3 } from "async-mutex";
-var mutex = new Mutex3();
-var singleton;
-var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex.runExclusive(async () => {
-    if (singleton) return singleton;
-    const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
-    const nodeUrl = getUrl(host, port);
-    const bridge = await initBridge(nodeUrl);
-    singleton = await initBridgedArchivistModule({
-      bridge,
-      moduleName: "XYOChain:Chain:Submissions"
-    });
-    return assertEx3(singleton, () => new Error("Failed to initialize RemoteChainSubmissionsArchivist"));
-  });
-}, "initRemoteChainSubmissionsArchivist");
-
-// src/orchestration/archivists/ChainSubmissions/archivist.ts
-var mutex2 = new Mutex4();
-var singleton2;
-var initChainSubmissionsArchivist = /* @__PURE__ */ __name(async (params) => {
-  return await mutex2.runExclusive(async () => {
-    if (singleton2) return singleton2;
-    return await timeBudget("initChainSubmissionsArchivist", params.logger, async () => {
-      const remote = await startupSpanAsync("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist(params));
-      singleton2 = remote;
-      return assertEx4(singleton2, () => new Error("Failed to initialize ChainSubmissionsArchivist"));
-    }, 2e3, true);
-  });
-}, "initChainSubmissionsArchivist");
-
-// src/orchestration/archivists/PendingTransactions/archivist.ts
-import { initArchivistSync } from "@xyo-network/chain-orchestration";
-import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex7 } from "async-mutex";
-
-// src/orchestration/archivists/PendingTransactions/local.ts
-import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex5 } from "async-mutex";
-var mutex3 = new Mutex5();
-var singleton3;
-var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
-  return await mutex3.runExclusive(async () => {
-    if (singleton3) return singleton3;
-    singleton3 = await MemoryArchivist.create({
-      account: "random",
-      config: {
-        schema: MemoryArchivistConfigSchema,
-        max: 1e3,
-        name: "localPendingTransactions"
-      }
-    });
-    return singleton3;
-  });
-}, "initLocalPendingTransactionsArchivist");
-
-// src/orchestration/archivists/PendingTransactions/remote.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
-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 Mutex6 } from "async-mutex";
-var mutex4 = new Mutex6();
-var singleton4;
-var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex4.runExclusive(async () => {
-    if (singleton4) return singleton4;
-    const { host, port } = config2.mempool.enabled ? config2.mempool : config2.api;
-    const nodeUrl = getUrl2(host, port);
-    const bridge = await initBridge2(nodeUrl);
-    singleton4 = await initBridgedArchivistModule2({
-      bridge,
-      moduleName: "XYOChain:Pending:PendingTransactions"
-    });
-    return assertEx5(singleton4, () => "RemotePendingBundledTransactionsArchivist is undefined");
-  });
-}, "initRemotePendingTransactionsArchivist");
-
-// src/orchestration/archivists/PendingTransactions/archivist.ts
-var mutex5 = new Mutex7();
-var singleton5;
-var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2, logger }) => {
-  return await mutex5.runExclusive(async () => {
-    if (singleton5) return singleton5;
-    return await timeBudget2("initPendingBundledTransactionsArchivist", logger, async () => {
-      const remote = await startupSpanAsync2("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist({
-        config: config2,
-        logger
-      }));
-      const local = await startupSpanAsync2("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist({
-        config: config2,
-        logger
-      }));
-      const start2 = await remote.next({
-        limit: 1,
-        order: "desc"
-      });
-      await local.insert(start2);
-      await startupSpanAsync2("PendingBundledTransactionsArchivist:initArchivistSync", () => initArchivistSync("PendingBundledTransactionsArchivist", remote, local));
-      singleton5 = [
-        local,
-        remote
-      ];
-      return singleton5;
-    }, 2e3, true);
-  });
-}, "initPendingBundledTransactionsArchivist");
-
-// src/orchestration/archivists/RejectedTransactions/archivist.ts
-import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget3 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex9 } from "async-mutex";
-
-// src/orchestration/archivists/RejectedTransactions/local.ts
-import { MemoryArchivist as MemoryArchivist2, MemoryArchivistConfigSchema as MemoryArchivistConfigSchema2 } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex8 } from "async-mutex";
-var mutex6 = new Mutex8();
-var singleton6;
-var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
-  return await mutex6.runExclusive(async () => {
-    if (singleton6) return singleton6;
-    singleton6 = await MemoryArchivist2.create({
-      account: "random",
-      config: {
-        schema: MemoryArchivistConfigSchema2,
-        max: 1e3,
-        name: "localRejectedTransactions"
-      }
-    });
-    return singleton6;
-  });
-}, "initLocalRejectedTransactionsArchivist");
-
-// src/orchestration/archivists/RejectedTransactions/archivist.ts
-var mutex7 = new Mutex9();
-var singleton7;
-async function initRejectedTransactionsArchivist(params) {
-  return await mutex7.runExclusive(async () => {
-    if (singleton7) return singleton7;
-    return await timeBudget3("initRejectedTransactionsArchivist", params.logger, async () => {
-      const local = await startupSpanAsync3("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
-      singleton7 = local;
-      return singleton7;
-    }, 2e3, true);
-  });
-}
-__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
-
-// src/orchestration/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget4 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex11 } from "async-mutex";
-
-// src/orchestration/archivists/StakeIntentState/local.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { Mutex as Mutex10 } from "async-mutex";
-var mutex8 = new Mutex10();
-var singleton8;
-var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  return await mutex8.runExclusive(async () => {
-    if (singleton8) return singleton8;
-    const { root } = config2.storage;
-    singleton8 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
-    return assertEx6(singleton8, () => new Error("Failed to initialize stake intent state archivist"));
-  });
-}, "initLocalStakeIntentStateArchivist");
-
-// src/orchestration/archivists/StakeIntentState/archivist.ts
-var mutex9 = new Mutex11();
-var singleton9;
-var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (params) => {
-  return await mutex9.runExclusive(async () => {
-    if (singleton9) return singleton9;
-    return await timeBudget4("initStakeIntentStateArchivist", params.logger, async () => {
-      const local = await startupSpanAsync4("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
-      singleton9 = local;
-      return assertEx7(singleton9, () => "StakeIntentStateArchivist is undefined");
-    }, 2e3, true);
-  });
-}, "initStakeIntentStateArchivist");
-
-// src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
-import { isDefined as isDefined4 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync5 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget5 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex13 } from "async-mutex";
-
-// src/orchestration/map/BalanceSummary/initLocalBalanceSummaryMap.ts
-import { isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { getLocalPersistentMap } from "@xyo-network/chain-protocol";
-import { Mutex as Mutex12 } from "async-mutex";
-var mutex10 = new Mutex12();
-var singleton10;
-var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(async (params) => {
-  return await mutex10.runExclusive(async () => {
-    if (isDefined3(singleton10)) return singleton10;
-    const { root } = params.config.storage;
-    singleton10 = await getLocalPersistentMap("balance", "summary", root);
-    return singleton10;
-  });
-}, "initLocalBalanceSummaryMap");
-
-// src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
-var mutex11 = new Mutex13();
-var singleton11;
-async function initBalanceSummaryMap(params) {
-  return await mutex11.runExclusive(async () => {
-    if (isDefined4(singleton11)) return singleton11;
-    return await timeBudget5("initBalanceSummaryMap", params.logger, async () => {
-      const local = await startupSpanAsync5("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap(params));
-      singleton11 = local;
-      return singleton11;
-    }, 2e3, true);
-  });
-}
-__name(initBalanceSummaryMap, "initBalanceSummaryMap");
-
-// src/orchestration/map/BalanceSummary/initTransferSummaryMap.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget6 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex15 } from "async-mutex";
-
-// src/orchestration/map/BalanceSummary/initLocalTransferSummaryMap.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { getLocalPersistentMap as getLocalPersistentMap2 } from "@xyo-network/chain-protocol";
-import { Mutex as Mutex14 } from "async-mutex";
-var mutex12 = new Mutex14();
-var singleton12;
-var initLocalTransferSummaryMap = /* @__PURE__ */ __name(async (params) => {
-  return await mutex12.runExclusive(async () => {
-    if (isDefined5(singleton12)) return singleton12;
-    const { root } = params.config.storage;
-    singleton12 = await getLocalPersistentMap2("transfer", "summary", root);
-    return singleton12;
-  });
-}, "initLocalTransferSummaryMap");
-
-// src/orchestration/map/BalanceSummary/initTransferSummaryMap.ts
-var mutex13 = new Mutex15();
-var singleton13;
-async function initTransferSummaryMap(params) {
-  return await mutex13.runExclusive(async () => {
-    if (isDefined6(singleton13)) return singleton13;
-    return await timeBudget6("initTransferSummaryMap:Init", params.logger, async () => {
-      const local = await startupSpanAsync6("TransferSummaryMap:initLocal", () => initLocalTransferSummaryMap(params));
-      singleton13 = local;
-      return singleton13;
-    }, 2e3, true);
-  });
-}
-__name(initTransferSummaryMap, "initTransferSummaryMap");
-
-// src/orchestration/services/implementation/accountBalance.ts
-import { isDefined as isDefined7 } from "@xylabs/sdk-js";
-import { AccountBalanceViewerRpcSchemas, HttpRpcTransport, JsonRpcAccountBalanceViewer } from "@xyo-network/xl1-rpc";
-var balanceServiceSingleton;
-var initAccountBalanceService = /* @__PURE__ */ __name((params) => {
-  const { config: config2, logger } = params;
-  if (balanceServiceSingleton) return balanceServiceSingleton;
-  const endpoint = config2.services?.accountBalanceViewerEndpoint ?? config2.services?.apiEndpoint;
-  if (isDefined7(endpoint)) {
-    const transport = new HttpRpcTransport(endpoint, {
-      ...AccountBalanceViewerRpcSchemas
-    });
-    const viewer = new JsonRpcAccountBalanceViewer(transport);
-    logger?.log("Using AccountBalanceViewer RPC service at", endpoint);
-    return viewer;
-  } else {
-    throw new Error("No AccountBalanceViewer endpoint configured");
-  }
-}, "initAccountBalanceService");
-
-// src/orchestration/services/implementation/blockViewer.ts
-import { isDefined as isDefined8 } from "@xylabs/sdk-js";
-import { BlockViewerRpcSchemas, HttpRpcTransport as HttpRpcTransport2, JsonRpcBlockViewer } from "@xyo-network/xl1-rpc";
-var blockViewerSingleton;
-var initBlockViewer = /* @__PURE__ */ __name((params) => {
-  const { config: config2, logger } = params;
-  if (blockViewerSingleton) return blockViewerSingleton;
-  const endpoint = config2.services?.apiEndpoint;
-  if (isDefined8(endpoint)) {
-    const transport = new HttpRpcTransport2(endpoint, {
-      ...BlockViewerRpcSchemas
-    });
-    const viewer = new JsonRpcBlockViewer(transport);
-    logger?.log("Using BlockViewer RPC service at", endpoint);
-    return viewer;
-  } else {
-    throw new Error("No BlockViewer endpoint configured");
-  }
-}, "initBlockViewer");
-
-// src/orchestration/services/implementation/chain/index.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
-import { MemoryChainService } from "@xyo-network/chain-services";
-
-// src/orchestration/services/implementation/chain/evm.ts
-import { asAddress, assertEx as assertEx12, isDefined as isDefined12, ZERO_ADDRESS } from "@xylabs/sdk-js";
-import { EvmChainService } from "@xyo-network/chain-services";
-import { Wallet } from "ethers/wallet";
-
-// src/orchestration/services/implementation/evm/initEvmProvider.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
-
-// src/orchestration/services/implementation/evm/initInfuraProvider.ts
-import { assertEx as assertEx9, isDefined as isDefined10 } from "@xylabs/sdk-js";
-import { InfuraProvider } from "ethers/providers";
-
-// src/orchestration/services/implementation/evm/initChainId.ts
-import { assertEx as assertEx8, hexFrom, isDefined as isDefined9, isHex } from "@xylabs/sdk-js";
-var canUseChainId = /* @__PURE__ */ __name((config2) => {
-  return isDefined9(config2.evm.chainId);
-}, "canUseChainId");
-var getChainId = /* @__PURE__ */ __name((config2) => {
-  const chainId = assertEx8(config2.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((config2) => {
-  if (instance) return instance;
-  const providerConfig = getInfuraProviderConfig(config2);
-  instance = Promise.resolve(new InfuraProvider(...providerConfig));
-  return instance;
-}, "initInfuraProvider");
-var canUseInfuraProvider = /* @__PURE__ */ __name((config2) => {
-  return canUseChainId(config2) && isDefined10(config2.evm?.infura?.projectId) && isDefined10(config2.evm?.infura?.projectSecret);
-}, "canUseInfuraProvider");
-var getInfuraProviderConfig = /* @__PURE__ */ __name((config2) => {
-  const projectId = assertEx9(config2.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx9(config2.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
-  return [
-    getChainId(config2),
-    projectId,
-    projectSecret
-  ];
-}, "getInfuraProviderConfig");
-
-// src/orchestration/services/implementation/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx10, isDefined as isDefined11 } from "@xylabs/sdk-js";
-import { JsonRpcProvider } from "ethers/providers";
-var initJsonRpcProvider = /* @__PURE__ */ __name((config2) => {
-  const providerConfig = getJsonRpcProviderConfig(config2);
-  return Promise.resolve(new JsonRpcProvider(...providerConfig));
-}, "initJsonRpcProvider");
-var canUseJsonRpcProvider = /* @__PURE__ */ __name((config2) => {
-  return canUseChainId(config2) && isDefined11(config2.evm.jsonRpc?.url);
-}, "canUseJsonRpcProvider");
-var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config2) => {
-  const jsonRpcUrl = assertEx10(config2.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
-  return [
-    jsonRpcUrl,
-    getChainId(config2)
-  ];
-}, "getJsonRpcProviderConfig");
-
-// src/orchestration/services/implementation/evm/initEvmProvider.ts
-var provider;
-var initEvmProvider = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  if (provider) return provider;
-  if (canUseInfuraProvider(config2)) {
-    provider = initInfuraProvider(config2);
-  } else if (canUseJsonRpcProvider(config2)) {
-    provider = initJsonRpcProvider(config2);
-  }
-  return assertEx11(await provider, () => "No provider available");
-}, "initEvmProvider");
-var canUseEvmProvider = /* @__PURE__ */ __name(({ config: config2 }) => {
-  return canUseInfuraProvider(config2) || canUseJsonRpcProvider(config2);
-}, "canUseEvmProvider");
-
-// src/orchestration/services/implementation/chain/evm.ts
-var chainStakeServiceSingleton;
-var canUseEvmContractChainService = /* @__PURE__ */ __name((config2) => {
-  const { id } = config2.chain;
-  return isDefined12(id) && id !== ZERO_ADDRESS && canUseEvmProvider({
-    config: config2
-  });
-}, "canUseEvmContractChainService");
-var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, config: config2, traceProvider, meterProvider, logger }) => {
-  if (chainStakeServiceSingleton) return chainStakeServiceSingleton;
-  const emvStakingContractAddress = assertEx12(config2.chain.id, () => "config.chain.id is required");
-  const id = assertEx12(asAddress(emvStakingContractAddress), () => "config.chain.id is not a valid address");
-  const provider2 = assertEx12(await initEvmProvider({
-    config: config2
-  }));
-  const privateKey = assertEx12(account.private?.hex, () => "Account does not have a private key");
-  const runner = new Wallet(privateKey, provider2);
-  chainStakeServiceSingleton = EvmChainService.create({
-    id,
-    runner,
-    traceProvider,
-    meterProvider,
-    logger
-  });
-  const result = await chainStakeServiceSingleton;
-  await result.start();
-  return result;
-}, "initEvmContractChainService");
-
-// src/orchestration/services/implementation/chain/index.ts
-var chainStakeServiceSingleton2;
-var initChainService = /* @__PURE__ */ __name(({ account, config: config2, logger }) => {
-  logger?.log("ChainService: Initializing...");
-  const result = init({
-    config: config2,
-    name: "ChainService",
-    account
-  });
-  logger?.log("ChainService: Initialized");
-  return result;
-}, "initChainService");
-var initMemoryChainService = /* @__PURE__ */ __name(async ({ config: config2 }) => {
-  const result = await MemoryChainService.create({
-    config: config2,
-    name: "MemoryChainService"
-  });
-  assertEx13(await result.start(), () => "Failed to start MemoryChainService");
-  return result;
-}, "initMemoryChainService");
-var init = /* @__PURE__ */ __name(async (params) => {
-  if (chainStakeServiceSingleton2) return chainStakeServiceSingleton2;
-  const { config: config2 } = params;
-  chainStakeServiceSingleton2 = canUseEvmContractChainService(config2) ? await initEvmContractChainService({
-    ...params,
-    name: "ChainStakeService"
-  }) : await initMemoryChainService(params);
-  return chainStakeServiceSingleton2;
-}, "init");
-
-// src/orchestration/services/implementation/pendingTransactions.ts
-import { isDefined as isDefined13 } from "@xylabs/sdk-js";
-import { BasePendingTransactionsService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget7 } from "@xyo-network/xl1-protocol-sdk";
-import { HttpRpcTransport as HttpRpcTransport3, JsonRpcMempoolViewer, MempoolViewerRpcSchemas } from "@xyo-network/xl1-rpc";
-var serviceSingleton;
-var initPendingTransactions = /* @__PURE__ */ __name(async ({ config: config2, params, logger }) => {
-  if (serviceSingleton) return serviceSingleton;
-  return await timeBudget7("initPendingTransactions", logger, async () => {
-    const endpoint = config2.services?.apiEndpoint;
-    if (isDefined13(endpoint)) {
-      const transport = new HttpRpcTransport3(endpoint, {
-        ...MempoolViewerRpcSchemas
-      });
-      const viewer = new JsonRpcMempoolViewer(transport);
-      logger?.log("Using MempoolViewer RPC service at", endpoint);
-      return viewer;
-    } else {
-      serviceSingleton = await BasePendingTransactionsService.create(params);
-    }
-    return serviceSingleton;
-  }, 2e3, true);
-}, "initPendingTransactions");
-
-// src/orchestration/services/implementation/producer.ts
-import { BaseBlockProducerService as BaseBlockProducerService2 } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget8 } from "@xyo-network/xl1-protocol-sdk";
-var serviceSingleton2;
-var initBlockProducer = /* @__PURE__ */ __name(async (params) => {
-  if (serviceSingleton2) return serviceSingleton2;
-  return await timeBudget8("initBlockProducer", params.logger, async () => {
-    serviceSingleton2 = await BaseBlockProducerService2.create(params);
-    return serviceSingleton2;
-  }, 2e3, true);
-}, "initBlockProducer");
-
-// src/orchestration/services/implementation/reward.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
-import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget9 } from "@xyo-network/xl1-protocol-sdk";
-var rewardServiceSingleton;
-var initBlockRewardService = /* @__PURE__ */ __name((params) => {
-  if (rewardServiceSingleton) return rewardServiceSingleton;
-  return timeBudget9("initBlockRewardService", params.logger, () => {
-    const { config: config2 } = params;
-    rewardServiceSingleton = canUseEvmBlockRewardService({
-      config: config2
-    }) ? initEvmBlockRewardService(params) : initXyoBlockRewardService(params);
-    return rewardServiceSingleton;
-  }, 2e3, true);
-}, "initBlockRewardService");
-var initXyoBlockRewardService = /* @__PURE__ */ __name((params) => {
-  if (rewardServiceSingleton) return rewardServiceSingleton;
-  return timeBudget9("initXyoBlockRewardService", params.logger, () => {
-    rewardServiceSingleton = MemoryBlockRewardService.create(params);
-    return rewardServiceSingleton;
-  }, 2e3, true);
-}, "initXyoBlockRewardService");
-var canUseEvmBlockRewardService = /* @__PURE__ */ __name((params) => canUseEvmProvider({
-  config: params.config
-}), "canUseEvmBlockRewardService");
-var initEvmBlockRewardService = /* @__PURE__ */ __name(async (params) => {
-  if (rewardServiceSingleton) return rewardServiceSingleton;
-  return await timeBudget9("initEvmBlockRewardService", params.logger, async () => {
-    const { account: paramsAccount } = params;
-    const account = assertEx14(paramsAccount, () => "Account is required");
-    const provider2 = assertEx14(await initEvmProvider(params));
-    const evmBlockRewardServiceParams = {
-      ...params,
-      provider: provider2,
-      account
-    };
-    rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams);
-    return rewardServiceSingleton;
-  }, 2e3, true);
-}, "initEvmBlockRewardService");
-
-// src/orchestration/services/implementation/time.ts
-import { BaseTimeSyncService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget10 } from "@xyo-network/xl1-protocol-sdk";
-var timeSyncServiceSingleton;
-var initTimeService = /* @__PURE__ */ __name(async ({ blockViewer, config: config2, logger, meterProvider, traceProvider }) => {
-  if (timeSyncServiceSingleton) return timeSyncServiceSingleton;
-  return await timeBudget10("initTimeService", logger, async () => {
-    const ethProvider = canUseEvmProvider({
-      config: config2
-    }) ? await initEvmProvider({
-      config: config2
-    }) : void 0;
-    timeSyncServiceSingleton = BaseTimeSyncService.create({
-      blockViewer,
-      ethProvider,
-      logger,
-      meterProvider,
-      traceProvider
-    });
-    return await timeSyncServiceSingleton;
-  }, 2e3, true);
-}, "initTimeService");
-
-// 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 isStartable = /* @__PURE__ */ __name((value) => {
-  const possibleStartable = value;
-  return isDefined14(possibleStartable.start) && typeof possibleStartable.start === "function" && possibleStartable.status === "created";
-}, "isStartable");
-var initServices = /* @__PURE__ */ __name(async (context) => {
-  const { config: config2, 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 { otlpEndpoint } = config2.telemetry?.otel ?? {};
-  const { path: endpoint = "/metrics", port = 9464 } = config2.telemetry?.metrics?.scrape ?? {};
-  const telemetryConfig = {
-    attributes: {
-      serviceName: "xl1-producer",
-      serviceVersion: "1.0.0"
-    },
-    otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
-  };
-  const [{ traceProvider, meterProvider }, account] = await Promise.all([
-    startupSpanAsync7("initTelemetry", () => initTelemetry(telemetryConfig)),
-    startupSpanAsync7("initProducerAccount", () => initProducerAccount(context))
-  ]);
-  const allowedRewardRedeemers = config2.validation?.allowedRewardRedeemers ?? [];
-  const allowedRewardEscrowAccountSigners = config2.validation?.allowedRewardEscrowAccountSigners ?? [];
-  const baseParamsFields = {
-    logger,
-    meterProvider,
-    traceProvider
-  };
-  const initParams = {
-    config: config2,
-    logger,
-    meterProvider,
-    statusReporter,
-    traceProvider
-  };
-  const [[pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite], rejectedTransactionsArchivist, chainSubmissionsArchivistWrite, stakeIntentStateArchivist, chainService, balanceSummaryMap] = await Promise.all([
-    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)),
-    startupSpanAsync7("TransferSummaryMap", () => initTransferSummaryMap(initParams))
-  ]);
-  const chainId = await chainService.chainId();
-  const chainContractViewer = chainService;
-  const chainStakeViewer = chainService;
-  const chainStaker = chainService;
-  const additionalPendingTransactionValidators = [
-    TransactionTransfersValidatorFactory([
-      SelfSignerValidator,
-      CompletedStepRewardAddressValidatorFactory(allowedRewardRedeemers),
-      DerivedReceiveAddressValidatorFactory(allowedRewardEscrowAccountSigners, "reward-escrow")
-    ])
-  ];
-  const [pendingTransactionsService, rewardService] = await Promise.all([
-    startupSpanAsync7("PendingTransactions", () => initPendingTransactions({
-      config: config2,
-      params: {
-        name: "PendingTransactionsService",
-        chainId,
-        pendingBundledTransactionsArchivist,
-        rejectedTransactionsArchivist,
-        additionalPendingTransactionValidators,
-        ...initParams
-      }
-    })),
-    startupSpanAsync7("RewardService", () => initBlockRewardService({
-      name: "RewardService",
-      account,
-      chainService,
-      ...initParams
-    }))
-  ]);
-  const blockViewer = await startupSpanAsync7("BlockViewer", () => initBlockViewer({
-    ...initParams
-  }));
-  const balanceService = await startupSpanAsync7("BalanceService", () => initAccountBalanceService({
-    ...initParams
-  }));
-  const [stakeIntentService, time] = await Promise.all([
-    startupSpanAsync7("StakeIntentService", () => initStakeIntentService({
-      name: "StakeIntentService",
-      blockViewer,
-      chainStakeViewer,
-      stakeIntentStateArchivist,
-      ...initParams
-    })),
-    startupSpanAsync7("TimeService", () => initTimeService({
-      name: "TimeService",
-      blockViewer,
-      ...initParams
-    }))
-  ]);
-  const electionService = await startupSpanAsync7("ElectionService", () => initElectionService({
-    name: "ElectionService",
-    blockViewer,
-    chainStakeViewer,
-    stakeIntentService,
-    ...initParams
-  }));
-  const validatorParams = {
-    name: "Validator",
-    account,
-    chainId,
-    pendingBundledTransactionsArchivist,
-    blockViewer,
-    electionService,
-    rewardService,
-    stakeIntentService,
-    validateHydratedBlockState,
-    ...initParams
-  };
-  const rewardAddress = isDefined14(config2.producer.rewardAddress) ? assertEx15(asAddress2(config2.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
-  const producerParams = {
-    ...validatorParams,
-    name: "Producer",
-    balanceService,
-    blockViewer,
-    pendingBundledTransactionsArchivist,
-    pendingTransactionsService,
-    rejectedTransactionsArchivist,
-    rewardAddress,
-    time,
-    ...initParams
-  };
-  const producer = await startupSpanAsync7("Producer", () => initBlockProducer(producerParams));
-  const services = {
-    account,
-    balance: balanceService,
-    chainContractViewer,
-    blockViewer,
-    chainStaker,
-    chainStakeViewer,
-    chainSubmissionsArchivistWrite,
-    election: electionService,
-    pendingBundledTransactionsArchivistWrite,
-    pendingTransactions: pendingTransactionsService,
-    producer,
-    reward: rewardService,
-    stakeIntent: stakeIntentService
-  };
-  logger?.log("All services created. Starting...");
-  const startableServices = [
-    balanceSummaryMap,
-    ...Object.values(services)
-  ].filter(isStartable);
-  assertEx15((await Promise.all(startableServices.map((service) => service.start()))).every(Boolean), () => "One or more services failed to start");
-  logger?.log("All services started successfully.");
-  return {
-    ...services,
-    ...baseParamsFields
-  };
-}, "initServices");
-
-// src/commands/producer/runProducer.ts
-var runProducer = /* @__PURE__ */ __name(async (context) => {
-  const { config: config2, logger, orchestrator } = context;
-  logger?.log("Services: Initializing...");
-  const services = await initServices(context);
-  logger?.log("Services: Initialized");
-  const params = {
-    ...services,
-    config: config2
-  };
-  const apiEndpoint = config2.services.apiEndpoint;
-  const balances = isDefined15(apiEndpoint) ? void 0 : await BalanceActor.create({
-    ...params,
-    name: "BalanceActor"
-  });
-  const producer = await ProducerActor.create({
-    ...params,
-    name: "ProducerActor"
-  });
-  const actors = [
-    balances,
-    producer
-  ].filter(exists);
-  for (const actor of actors) {
-    await orchestrator.registerActor(actor);
-  }
-  await orchestrator.start();
-}, "runProducer");
-
 // src/commands/rewardRedemption/runRewardRedemptionApi.ts
 import { getServer as getServer4 } from "@xyo-network/chain-reward-redemption";
 function runRewardRedemptionApi(context) {
@@ -1426,20 +62,20 @@ var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\
 \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, ConsoleLogger, isDefined as isDefined16, LogLevel, SilentLogger } from "@xylabs/sdk-js";
+import { Base, ConsoleLogger, isDefined, LogLevel, SilentLogger } from "@xylabs/sdk-js";
 var initLogger = /* @__PURE__ */ __name((config2) => {
   let logger;
   if (config2.silent) {
     logger = new SilentLogger();
   } else {
     let level;
-    if (isDefined16(config2.logLevel)) {
+    if (isDefined(config2.logLevel)) {
       const parsed = LogLevel[config2.logLevel.toLowerCase()];
-      if (isDefined16(parsed)) level = parsed;
+      if (isDefined(parsed)) level = parsed;
     }
     logger = new ConsoleLogger(level);
   }
-  Base2.defaultLogger = logger;
+  Base.defaultLogger = logger;
   return logger;
 }, "initLogger");
 
@@ -1461,7 +97,7 @@ var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
 }, "optionsFromGlobalZodRegistry");
 
 // src/tryParseConfig.ts
-import { isDefined as isDefined17, isNull } from "@xylabs/sdk-js";
+import { isDefined as isDefined2, isNull } from "@xylabs/sdk-js";
 import { cosmiconfigSync } from "cosmiconfig";
 var configName = "xyo";
 var configSection = "xl1";
@@ -1470,7 +106,7 @@ var tryParseConfig = /* @__PURE__ */ __name(() => {
   const result = explorer.search();
   if (!isNull(result)) {
     const section = result?.config?.[configSection];
-    if (isDefined17(section) && typeof section === "object") {
+    if (isDefined2(section) && typeof section === "object") {
       return section;
     }
   }
@@ -1500,10 +136,12 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined18("1.16.26") ? "1.16.26" : "unknown";
-var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
+var version = isDefined3("1.17.1") ? "1.17.1" : "unknown";
+var getContextFromConfig = /* @__PURE__ */ __name(async (configuration2) => {
   const logger = initLogger(configuration2);
-  const orchestrator = new Orchestrator(logger);
+  const orchestrator = await Orchestrator.create({
+    logger
+  });
   process.on("SIGINT", () => {
     void (async () => {
       try {
@@ -1548,8 +186,8 @@ $0 <command> [options]`).parserConfiguration({
     }
   }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command("api", "Run a XL1 API Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 API Node", () => {
-    }, () => {
-      const context = getContextFromConfig(configuration);
+    }, async () => {
+      const context = await getContextFromConfig(configuration);
       runApi({
         ...context,
         config: configuration
@@ -1557,8 +195,8 @@ $0 <command> [options]`).parserConfiguration({
     });
   }).command("bridge", "Run a XL1 Bridge Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Bridge Node", () => {
-    }, () => {
-      const context = getContextFromConfig(configuration);
+    }, async () => {
+      const context = await getContextFromConfig(configuration);
       runBridge({
         ...context,
         config: configuration
@@ -1566,8 +204,8 @@ $0 <command> [options]`).parserConfiguration({
     });
   }).command("mempool", "Run a XL1 Mempool Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Mempool Node", () => {
-    }, () => {
-      const context = getContextFromConfig(configuration);
+    }, async () => {
+      const context = await getContextFromConfig(configuration);
       runMempool({
         ...context,
         config: configuration
@@ -1576,7 +214,7 @@ $0 <command> [options]`).parserConfiguration({
   }).command("producer", "Run a XL1 Producer Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Producer Node", () => {
     }, async () => {
-      const context = getContextFromConfig(configuration);
+      const context = await getContextFromConfig(configuration);
       await runProducer({
         ...context,
         config: configuration
@@ -1584,8 +222,8 @@ $0 <command> [options]`).parserConfiguration({
     });
   }).command("reward-redemption-api", "Run a XL1 Rewards Redemption API Node", (yargs2) => {
     return yargs2.command("$0", "Run a XL1 Rewards Redemption API Node", () => {
-    }, () => {
-      const context = getContextFromConfig(configuration);
+    }, async () => {
+      const context = await getContextFromConfig(configuration);
       runRewardRedemptionApi({
         ...context,
         config: configuration
@@ -1593,7 +231,7 @@ $0 <command> [options]`).parserConfiguration({
     });
   }).command("$0", "Run a full XL1 Node", () => {
   }, async () => {
-    const context = getContextFromConfig(configuration);
+    const context = await getContextFromConfig(configuration);
     if (configuration.mempool.enabled) {
       runMempool({
         ...context,