@xyo-network/xl1-cli-lib 1.16.21 → 1.16.23

package/dist/node/index.mjs

@@ -223,7 +223,7 @@ var BalanceActor = class _BalanceActor extends Actor {
     if (this._updateMutex.isLocked()) return;
     await this._updateMutex.runExclusive(async () => {
       const head = await PayloadBuilder.hash(await this.chainIterator.head());
-      await this.balanceService.accountBalances([], head);
+      await this.balanceService.accountsBalances([], head);
     });
   }
 };
@@ -232,10 +232,12 @@ var BalanceActor = class _BalanceActor extends Actor {
 import { assertEx as assertEx2, filterAs, toHex } from "@xylabs/sdk-js";
 import { findMostRecentBlock, sortBlocks } from "@xyo-network/chain-protocol";
 import { asBlockBoundWitness } from "@xyo-network/xl1-protocol";
+import { Mutex as Mutex2 } from "async-mutex";
 var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
   static {
     __name(this, "ChainHeadUpdateActor");
   }
+  _pollForNewHeadMutex = new Mutex2();
   constructor(params) {
     super("ChainHeadUpdate", "ChainHeadUpdate", params);
   }
@@ -266,8 +268,14 @@ var ChainHeadUpdateActor = class _ChainHeadUpdateActor extends Actor {
     await this.updateHeadIfNewer(candidateBlock);
   }
   async pollForNewHead() {
-    const candidateBlock = await findMostRecentBlock(this.chainFinalizedArchivist);
-    await this.updateHeadIfNewer(candidateBlock);
+    if (this._pollForNewHeadMutex.isLocked()) {
+      this.logger?.log("Skipping poll for new head, previous poll still in progress");
+      return;
+    }
+    await this._pollForNewHeadMutex.runExclusive(async () => {
+      const candidateBlock = await findMostRecentBlock(this.chainFinalizedArchivist);
+      await this.updateHeadIfNewer(candidateBlock);
+    });
   }
   async updateHeadIfNewer(candidateBlock) {
     if (!candidateBlock) return;
@@ -290,6 +298,7 @@ import { BaseBlockProducerService } from "@xyo-network/chain-services";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
 import { PayloadBundleSchema } from "@xyo-network/payload-model";
 import { buildTransaction, flattenHydratedBlock, flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex3 } from "async-mutex";
 var SHOULD_REGISTER_REDECLARATION_INTENT_TIMER = true;
 var TEN_MINUTES = 10 * 60 * 1e3;
 var ProducerActor = class _ProducerActor extends Actor {
@@ -298,6 +307,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   }
   _lastProducedBlock;
   _lastRedeclarationIntent;
+  _produceBlockMutex = new Mutex3();
   constructor(params) {
     super(params.producer.address, "Producer", params);
   }
@@ -335,7 +345,7 @@ var ProducerActor = class _ProducerActor extends Actor {
       async () => {
         await this.produceBlock();
       },
-      100,
+      2e3,
       1500
       /* 500 */
     );
@@ -357,30 +367,36 @@ var ProducerActor = class _ProducerActor extends Actor {
   }
   async produceBlock() {
     await this.spanAsync("produceBlock", async () => {
-      const headStart = Date.now();
-      const head = await this.chainIterator.head();
-      const headDuration = Date.now() - headStart;
-      if (headDuration > 500) {
-        this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex2(head._hash)}`);
+      if (this._produceBlockMutex.isLocked()) {
+        this.logger?.log("Skipping block production, previous production still in progress");
+        return;
       }
-      const headHash = head._hash;
-      if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
-        this.logger?.log("Block already produced:", `0x${toHex2(this._lastProducedBlock[0].block)}`);
-      } else {
-        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}`);
+      await this._produceBlockMutex.runExclusive(async () => {
+        const headStart = Date.now();
+        const head = await this.chainIterator.head();
+        const headDuration = Date.now() - headStart;
+        if (headDuration > 500) {
+          this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex2(head._hash)}`);
         }
-        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;
+        const headHash = head._hash;
+        if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
+          this.logger?.log("Block already produced:", `0x${toHex2(this._lastProducedBlock[0].block)}`, this._lastProducedBlock[0].block);
+        } else {
+          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${toHex2(nextBlock[0].block)}`;
+            this.logger?.log("Produced block:", displayBlockNumber);
+            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock));
+            this.logger?.log("Published block:", displayBlockNumber, nextBlock[0].block);
+            this._lastProducedBlock = nextBlock;
+          }
         }
-      }
+      });
     });
   }
   async redeclareIntent() {
@@ -433,7 +449,7 @@ var ProducerActor = class _ProducerActor extends Actor {
   async validateCurrentBalance() {
     const head = this._lastProducedBlock?.[0]._hash;
     if (isDefined(head)) {
-      const balances = await this.balanceService.accountBalances([
+      const balances = await this.balanceService.accountsBalances([
         this.account.address
       ], head);
       const currentBalance = balances[this.account.address] ?? 0n;
@@ -518,7 +534,7 @@ var ValidatorActor = class _ValidatorActor extends Actor {
           }
         });
       },
-      100,
+      2e3,
       1500
       /* 500 */
     );
@@ -592,7 +608,7 @@ var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
 }, "initHealthEndpoints");
 
 // src/orchestration/initServices.ts
-import { asAddress as asAddress2, assertEx as assertEx18, isDefined as isDefined14 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx19, isDefined as isDefined14 } from "@xylabs/sdk-js";
 import { initProducerAccount } from "@xyo-network/chain-orchestration";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
 import { startupSpanAsync as startupSpanAsync8 } from "@xyo-network/chain-utils";
@@ -605,10 +621,11 @@ import { Semaphore as Semaphore2 } from "async-mutex";
 // 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";
+import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex6 } from "async-mutex";
 
 // src/orchestration/archivists/ChainFinalized/local.ts
-import { Mutex as Mutex2 } from "async-mutex";
+import { Mutex as Mutex4 } from "async-mutex";
 
 // src/orchestration/archivists/lib/localPersistentArchivist.ts
 import { rm } from "fs/promises";
@@ -636,7 +653,7 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeNam
 }, "getLocalPersistentArchivist");
 
 // src/orchestration/archivists/ChainFinalized/local.ts
-var mutex = new Mutex2();
+var mutex = new Mutex4();
 var singleton;
 var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex.runExclusive(async () => {
@@ -651,8 +668,8 @@ var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: c
 import { assertEx as assertEx5 } 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 mutex2 = new Mutex3();
+import { Mutex as Mutex5 } from "async-mutex";
+var mutex2 = new Mutex5();
 var singleton2;
 var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex2.runExclusive(async () => {
@@ -669,24 +686,26 @@ var initRemoteChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config:
 }, "initRemoteChainFinalizedArchivist");
 
 // src/orchestration/archivists/ChainFinalized/archivist.ts
-var mutex3 = new Mutex4();
+var mutex3 = new Mutex6();
 var singleton3;
 async function initChainFinalizedArchivist({ config: config2, logger, traceProvider }) {
   return await mutex3.runExclusive(async () => {
     if (singleton3) return singleton3;
-    const [remote, local] = await Promise.all([
-      startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist({
-        config: config2,
-        logger
-      })),
-      startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
-        config: config2,
-        logger
-      }))
-    ]);
-    await startupSpanAsync("ChainFinalizedArchivist:initArchivistSync", () => initArchivistSync("ChainFinalizedArchivist", remote, local, 200, Number.MAX_SAFE_INTEGER, traceProvider));
-    singleton3 = local;
-    return singleton3;
+    return await timeBudget("initChainFinalizedArchivist", logger, async () => {
+      const [remote, local] = await Promise.all([
+        startupSpanAsync("ChainFinalizedArchivist:initRemote", () => initRemoteChainFinalizedArchivist({
+          config: config2,
+          logger
+        })),
+        startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
+          config: config2,
+          logger
+        }))
+      ]);
+      await startupSpanAsync("ChainFinalizedArchivist:initArchivistSync", () => initArchivistSync("ChainFinalizedArchivist", remote, local, 200, Number.MAX_SAFE_INTEGER, traceProvider));
+      singleton3 = local;
+      return singleton3;
+    }, 2e3, true);
   });
 }
 __name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
@@ -694,14 +713,15 @@ __name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
 // src/orchestration/archivists/ChainSubmissions/archivist.ts
 import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex6 } from "async-mutex";
+import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex8 } from "async-mutex";
 
 // src/orchestration/archivists/ChainSubmissions/remote.ts
 import { assertEx as assertEx6 } 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 Mutex5 } from "async-mutex";
-var mutex4 = new Mutex5();
+import { Mutex as Mutex7 } from "async-mutex";
+var mutex4 = new Mutex7();
 var singleton4;
 var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex4.runExclusive(async () => {
@@ -718,26 +738,29 @@ var initRemoteChainSubmissionsArchivist = /* @__PURE__ */ __name(async ({ config
 }, "initRemoteChainSubmissionsArchivist");
 
 // src/orchestration/archivists/ChainSubmissions/archivist.ts
-var mutex5 = new Mutex6();
+var mutex5 = new Mutex8();
 var singleton5;
 var initChainSubmissionsArchivist = /* @__PURE__ */ __name(async (params) => {
   return await mutex5.runExclusive(async () => {
     if (singleton5) return singleton5;
-    const remote = await startupSpanAsync2("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist(params));
-    singleton5 = remote;
-    return assertEx7(singleton5, () => new Error("Failed to initialize ChainSubmissionsArchivist"));
+    return await timeBudget2("initChainSubmissionsArchivist", params.logger, async () => {
+      const remote = await startupSpanAsync2("ChainSubmissionsArchivist:initRemote", () => initRemoteChainSubmissionsArchivist(params));
+      singleton5 = remote;
+      return assertEx7(singleton5, () => new Error("Failed to initialize ChainSubmissionsArchivist"));
+    }, 2e3, true);
   });
 }, "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";
+import { timeBudget as timeBudget3 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex11 } 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();
+import { Mutex as Mutex9 } from "async-mutex";
+var mutex6 = new Mutex9();
 var singleton6;
 var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex6.runExclusive(async () => {
@@ -758,8 +781,8 @@ var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async () => {
 import { assertEx as assertEx8 } from "@xylabs/sdk-js";
 import { initBridge as initBridge3, initBridgedArchivistModule as initBridgedArchivistModule3 } from "@xyo-network/chain-orchestration";
 import { getUrl as getUrl3 } from "@xyo-network/xl1-protocol-sdk";
-import { Mutex as Mutex8 } from "async-mutex";
-var mutex7 = new Mutex8();
+import { Mutex as Mutex10 } from "async-mutex";
+var mutex7 = new Mutex10();
 var singleton7;
 var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex7.runExclusive(async () => {
@@ -776,35 +799,44 @@ var initRemotePendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ con
 }, "initRemotePendingTransactionsArchivist");
 
 // src/orchestration/archivists/PendingTransactions/archivist.ts
-var mutex8 = new Mutex9();
+var mutex8 = new Mutex11();
 var singleton8;
-var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(async (params) => {
+var initPendingBundledTransactionsArchivist = /* @__PURE__ */ __name(async ({ config: config2, logger }) => {
   return await mutex8.runExclusive(async () => {
     if (singleton8) return singleton8;
-    const remote = await startupSpanAsync3("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist(params));
-    const local = await startupSpanAsync3("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist(params));
-    const start2 = await remote.next({
-      limit: 1,
-      order: "desc"
-    });
-    await local.insert(start2);
-    await startupSpanAsync3("PendingBundledTransactionsArchivist:initArchivistSync", () => initArchivistSync2("PendingBundledTransactionsArchivist", remote, local));
-    singleton8 = [
-      local,
-      remote
-    ];
-    return singleton8;
+    return await timeBudget3("initPendingBundledTransactionsArchivist", logger, async () => {
+      const remote = await startupSpanAsync3("PendingBundledTransactionsArchivist:initRemote", () => initRemotePendingTransactionsArchivist({
+        config: config2,
+        logger
+      }));
+      const local = await startupSpanAsync3("PendingBundledTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist({
+        config: config2,
+        logger
+      }));
+      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;
+    }, 2e3, true);
   });
 }, "initPendingBundledTransactionsArchivist");
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
 import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex11 } from "async-mutex";
+import { timeBudget as timeBudget4 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex13 } 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();
+import { Mutex as Mutex12 } from "async-mutex";
+var mutex9 = new Mutex12();
 var singleton9;
 var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex9.runExclusive(async () => {
@@ -822,14 +854,16 @@ var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () =>
 }, "initLocalRejectedTransactionsArchivist");
 
 // src/orchestration/archivists/RejectedTransactions/archivist.ts
-var mutex10 = new Mutex11();
+var mutex10 = new Mutex13();
 var singleton10;
 async function initRejectedTransactionsArchivist(params) {
   return await mutex10.runExclusive(async () => {
     if (singleton10) return singleton10;
-    const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
-    singleton10 = local;
-    return singleton10;
+    return await timeBudget4("initRejectedTransactionsArchivist", params.logger, async () => {
+      const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
+      singleton10 = local;
+      return singleton10;
+    }, 2e3, true);
   });
 }
 __name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
@@ -837,12 +871,13 @@ __name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 // src/orchestration/archivists/StakeIntentState/archivist.ts
 import { assertEx as assertEx10 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync5 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex13 } from "async-mutex";
+import { timeBudget as timeBudget5 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex15 } from "async-mutex";
 
 // src/orchestration/archivists/StakeIntentState/local.ts
 import { assertEx as assertEx9 } from "@xylabs/sdk-js";
-import { Mutex as Mutex12 } from "async-mutex";
-var mutex11 = new Mutex12();
+import { Mutex as Mutex14 } from "async-mutex";
+var mutex11 = new Mutex14();
 var singleton11;
 var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config: config2 }) => {
   return await mutex11.runExclusive(async () => {
@@ -854,27 +889,30 @@ var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config:
 }, "initLocalStakeIntentStateArchivist");
 
 // src/orchestration/archivists/StakeIntentState/archivist.ts
-var mutex12 = new Mutex13();
+var mutex12 = new Mutex15();
 var singleton12;
 var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (params) => {
   return await mutex12.runExclusive(async () => {
     if (singleton12) return singleton12;
-    const local = await startupSpanAsync5("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
-    singleton12 = local;
-    return assertEx10(singleton12, () => "StakeIntentStateArchivist is undefined");
+    return await timeBudget5("initStakeIntentStateArchivist", params.logger, async () => {
+      const local = await startupSpanAsync5("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
+      singleton12 = local;
+      return assertEx10(singleton12, () => "StakeIntentStateArchivist is undefined");
+    }, 2e3, true);
   });
 }, "initStakeIntentStateArchivist");
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
 import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync6 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex15 } from "async-mutex";
+import { timeBudget as timeBudget6 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex17 } from "async-mutex";
 
 // src/orchestration/map/BalanceSummary/initLocalBalanceSummaryMap.ts
 import { isDefined as isDefined4 } from "@xylabs/sdk-js";
 import { getLocalPersistentMap } from "@xyo-network/chain-protocol";
-import { Mutex as Mutex14 } from "async-mutex";
-var mutex13 = new Mutex14();
+import { Mutex as Mutex16 } from "async-mutex";
+var mutex13 = new Mutex16();
 var singleton13;
 var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(async (params) => {
   return await mutex13.runExclusive(async () => {
@@ -886,14 +924,16 @@ var initLocalBalanceSummaryMap = /* @__PURE__ */ __name(async (params) => {
 }, "initLocalBalanceSummaryMap");
 
 // src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts
-var mutex14 = new Mutex15();
+var mutex14 = new Mutex17();
 var singleton14;
 async function initBalanceSummaryMap(params) {
   return await mutex14.runExclusive(async () => {
     if (isDefined5(singleton14)) return singleton14;
-    const local = await startupSpanAsync6("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap(params));
-    singleton14 = local;
-    return singleton14;
+    return await timeBudget6("initBalanceSummaryMap", params.logger, async () => {
+      const local = await startupSpanAsync6("BalanceSummaryMap:initLocal", () => initLocalBalanceSummaryMap(params));
+      singleton14 = local;
+      return singleton14;
+    }, 2e3, true);
   });
 }
 __name(initBalanceSummaryMap, "initBalanceSummaryMap");
@@ -901,13 +941,14 @@ __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 // src/orchestration/map/BalanceSummary/initTransferSummaryMap.ts
 import { isDefined as isDefined7 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync7 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex17 } from "async-mutex";
+import { timeBudget as timeBudget7 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex19 } from "async-mutex";
 
 // src/orchestration/map/BalanceSummary/initLocalTransferSummaryMap.ts
 import { isDefined as isDefined6 } from "@xylabs/sdk-js";
 import { getLocalPersistentMap as getLocalPersistentMap2 } from "@xyo-network/chain-protocol";
-import { Mutex as Mutex16 } from "async-mutex";
-var mutex15 = new Mutex16();
+import { Mutex as Mutex18 } from "async-mutex";
+var mutex15 = new Mutex18();
 var singleton15;
 var initLocalTransferSummaryMap = /* @__PURE__ */ __name(async (params) => {
   return await mutex15.runExclusive(async () => {
@@ -919,28 +960,34 @@ var initLocalTransferSummaryMap = /* @__PURE__ */ __name(async (params) => {
 }, "initLocalTransferSummaryMap");
 
 // src/orchestration/map/BalanceSummary/initTransferSummaryMap.ts
-var mutex16 = new Mutex17();
+var mutex16 = new Mutex19();
 var singleton16;
 async function initTransferSummaryMap(params) {
   return await mutex16.runExclusive(async () => {
     if (isDefined7(singleton16)) return singleton16;
-    const local = await startupSpanAsync7("TransferSummaryMap:initLocal", () => initLocalTransferSummaryMap(params));
-    singleton16 = local;
-    return singleton16;
+    return await timeBudget7("initTransferSummaryMap:Init", params.logger, async () => {
+      const local = await startupSpanAsync7("TransferSummaryMap:initLocal", () => initLocalTransferSummaryMap(params));
+      singleton16 = local;
+      return singleton16;
+    }, 2e3, true);
   });
 }
 __name(initTransferSummaryMap, "initTransferSummaryMap");
 
 // src/orchestration/services/implementation/balance.ts
 import { BaseAccountBalanceService } from "@xyo-network/chain-services";
+import { timeBudget as timeBudget8 } from "@xyo-network/xl1-protocol-sdk";
 var balanceServiceSingleton;
 var initBalanceService = /* @__PURE__ */ __name(async (params) => {
   if (balanceServiceSingleton) return balanceServiceSingleton;
-  balanceServiceSingleton = await BaseAccountBalanceService.create(params);
-  return balanceServiceSingleton;
+  return await timeBudget8("initBalanceService", params.logger, async () => {
+    balanceServiceSingleton = await BaseAccountBalanceService.create(params);
+    return balanceServiceSingleton;
+  }, 2e3, true);
 }, "initBalanceService");
 
 // src/orchestration/services/implementation/chain/index.ts
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
 import { MemoryChainService } from "@xyo-network/chain-services";
 
 // src/orchestration/services/implementation/chain/evm.ts
@@ -1052,31 +1099,43 @@ var initEvmContractChainService = /* @__PURE__ */ __name(async ({ account, confi
     meterProvider,
     logger
   });
-  return await chainStakeServiceSingleton;
+  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 }) => init({
-  config: config2,
-  name: "ChainService",
-  account
-}), "initChainService");
-var init = /* @__PURE__ */ __name((params) => {
+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"
+  });
+  assertEx16(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) ? initEvmContractChainService({
+  chainStakeServiceSingleton2 = canUseEvmContractChainService(config2) ? await initEvmContractChainService({
     ...params,
     name: "ChainStakeService"
-  }) : MemoryChainService.create({
-    ...params,
-    name: "ChainStakeService"
-  });
+  }) : await initMemoryChainService(params);
   return chainStakeServiceSingleton2;
 }, "init");
 
 // src/orchestration/services/implementation/head/head.ts
-import { assertEx as assertEx16, isDefined as isDefined13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17, isDefined as isDefined13 } from "@xylabs/sdk-js";
 import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
 
 // src/orchestration/services/implementation/head/createBootstrapHead.ts
@@ -1297,13 +1356,13 @@ var initHead = /* @__PURE__ */ __name(async (params) => {
     if (isDefined13(forkFromBlock)) {
       const chain = await createForkedHead(forkFromBlock, account, chainService);
       await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
-      const newBlock = assertEx16(chain.at(-1), () => new Error("Failed to get new head after forking"));
+      const newBlock = assertEx17(chain.at(-1), () => new Error("Failed to get new head after forking"));
       head = newBlock[0];
     }
   } else {
     const chain = await createBootstrapHead(account, chainService);
     await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite);
-    const newBlock = assertEx16(chain.at(-1), () => new Error("Failed to get new head after genesis"));
+    const newBlock = assertEx17(chain.at(-1), () => new Error("Failed to get new head after genesis"));
     head = newBlock[0];
   }
   headSingleton = head;
@@ -1312,105 +1371,131 @@ var initHead = /* @__PURE__ */ __name(async (params) => {
 
 // src/orchestration/services/implementation/iterator.ts
 import { BaseElectionService, ChainBlockNumberIterationService, XyoStakeIntentService } from "@xyo-network/chain-services";
+import { timeBudget as timeBudget9 } from "@xyo-network/xl1-protocol-sdk";
 var chainIteratorServiceSingleton;
 var stakeIntentServiceSingleton;
 var electionServiceSingleton;
 var initChainIterator = /* @__PURE__ */ __name((params) => {
   if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
-  chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
-  return chainIteratorServiceSingleton;
+  return timeBudget9("initChainIterator", params.logger, () => {
+    chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
+    return chainIteratorServiceSingleton;
+  }, 2e3, true);
 }, "initChainIterator");
 var initStakeIntentService = /* @__PURE__ */ __name((params) => {
   if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
-  stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
-  return stakeIntentServiceSingleton;
+  return timeBudget9("initStakeIntentService", params.logger, () => {
+    stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
+    return stakeIntentServiceSingleton;
+  }, 2e3, true);
 }, "initStakeIntentService");
 var initElectionService = /* @__PURE__ */ __name((params) => {
   if (electionServiceSingleton) return electionServiceSingleton;
-  electionServiceSingleton = BaseElectionService.create(params);
-  return electionServiceSingleton;
+  return timeBudget9("initElectionService", params.logger, () => {
+    electionServiceSingleton = BaseElectionService.create(params);
+    return electionServiceSingleton;
+  }, 2e3, true);
 }, "initElectionService");
 
 // src/orchestration/services/implementation/pendingTransactions.ts
 import { BasePendingTransactionsService } from "@xyo-network/chain-services";
+import { timeBudget as timeBudget10 } from "@xyo-network/xl1-protocol-sdk";
 var serviceSingleton;
 var initPendingTransactions = /* @__PURE__ */ __name(async (params) => {
   if (serviceSingleton) return serviceSingleton;
-  serviceSingleton = await BasePendingTransactionsService.create(params);
-  return serviceSingleton;
+  return await timeBudget10("initPendingTransactions", params.logger, async () => {
+    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 timeBudget11 } from "@xyo-network/xl1-protocol-sdk";
 var serviceSingleton2;
 var initBlockProducer = /* @__PURE__ */ __name(async (params) => {
   if (serviceSingleton2) return serviceSingleton2;
-  serviceSingleton2 = await BaseBlockProducerService2.create(params);
-  return serviceSingleton2;
+  return await timeBudget11("initBlockProducer", params.logger, async () => {
+    serviceSingleton2 = await BaseBlockProducerService2.create(params);
+    return serviceSingleton2;
+  }, 2e3, true);
 }, "initBlockProducer");
 
 // src/orchestration/services/implementation/reward.ts
-import { assertEx as assertEx17 } from "@xylabs/sdk-js";
+import { assertEx as assertEx18 } from "@xylabs/sdk-js";
 import { EvmBlockRewardService, MemoryBlockRewardService } from "@xyo-network/chain-services";
+import { timeBudget as timeBudget12 } from "@xyo-network/xl1-protocol-sdk";
 var rewardServiceSingleton;
 var initBlockRewardService = /* @__PURE__ */ __name((params) => {
   if (rewardServiceSingleton) return rewardServiceSingleton;
-  const { config: config2 } = params;
-  rewardServiceSingleton = canUseEvmBlockRewardService({
-    config: config2
-  }) ? initEvmBlockRewardService(params) : initXyoBlockRewardService(params);
-  return rewardServiceSingleton;
+  return timeBudget12("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;
-  rewardServiceSingleton = MemoryBlockRewardService.create(params);
-  return rewardServiceSingleton;
+  return timeBudget12("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;
-  const { account: paramsAccount } = params;
-  const account = assertEx17(paramsAccount, () => "Account is required");
-  const provider2 = assertEx17(await initEvmProvider(params));
-  const evmBlockRewardServiceParams = {
-    ...params,
-    provider: provider2,
-    account
-  };
-  rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams);
-  return rewardServiceSingleton;
+  return await timeBudget12("initEvmBlockRewardService", params.logger, async () => {
+    const { account: paramsAccount } = params;
+    const account = assertEx18(paramsAccount, () => "Account is required");
+    const provider2 = assertEx18(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 timeBudget13 } from "@xyo-network/xl1-protocol-sdk";
 var timeSyncServiceSingleton;
 var initTimeService = /* @__PURE__ */ __name(async ({ chainArchivist, chainIterator, config: config2, logger, meterProvider, traceProvider }) => {
   if (timeSyncServiceSingleton) return timeSyncServiceSingleton;
-  const ethProvider = canUseEvmProvider({
-    config: config2
-  }) ? await initEvmProvider({
-    config: config2
-  }) : void 0;
-  timeSyncServiceSingleton = BaseTimeSyncService.create({
-    chainArchivist,
-    chainIterator,
-    ethProvider,
-    logger,
-    meterProvider,
-    traceProvider
-  });
-  return await timeSyncServiceSingleton;
+  return await timeBudget13("initTimeService", logger, async () => {
+    const ethProvider = canUseEvmProvider({
+      config: config2
+    }) ? await initEvmProvider({
+      config: config2
+    }) : void 0;
+    timeSyncServiceSingleton = BaseTimeSyncService.create({
+      chainArchivist,
+      chainIterator,
+      ethProvider,
+      logger,
+      meterProvider,
+      traceProvider
+    });
+    return await timeSyncServiceSingleton;
+  }, 2e3, true);
 }, "initTimeService");
 
 // src/orchestration/services/implementation/transfer.ts
 import { BaseAccountTransfersService } from "@xyo-network/chain-services";
+import { timeBudget as timeBudget14 } from "@xyo-network/xl1-protocol-sdk";
 var transferServiceSingleton;
 var initTransferService = /* @__PURE__ */ __name(async (params) => {
   if (transferServiceSingleton) return transferServiceSingleton;
-  transferServiceSingleton = await BaseAccountTransfersService.create(params);
-  return transferServiceSingleton;
+  return await timeBudget14("initTransferService", params.logger, async () => {
+    transferServiceSingleton = await BaseAccountTransfersService.create(params);
+    return transferServiceSingleton;
+  }, 2e3, true);
 }, "initTransferService");
 
 // src/orchestration/services/implementation/validator.ts
@@ -1513,7 +1598,8 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 
 // src/orchestration/initServices.ts
 var isStartable = /* @__PURE__ */ __name((value) => {
-  return isDefined14(value.start) && typeof value.start === "function";
+  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;
@@ -1694,7 +1780,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     validateHydratedBlockState,
     ...initParams
   };
-  const rewardAddress = isDefined14(config2.producer.rewardAddress) ? assertEx18(asAddress2(config2.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
+  const rewardAddress = isDefined14(config2.producer.rewardAddress) ? assertEx19(asAddress2(config2.producer.rewardAddress), () => "Invalid block reward address provided") : account.address;
   const producerParams = {
     ...validatorParams,
     name: "Producer",
@@ -1729,7 +1815,7 @@ var initServices = /* @__PURE__ */ __name(async (context) => {
     balanceSummaryMap,
     ...Object.values(result)
   ].filter(isStartable);
-  assertEx18((await Promise.all(startableServices.map((service) => service.start()))).every(Boolean), () => "One or more services failed to start");
+  assertEx19((await Promise.all(startableServices.map((service) => service.start()))).every(Boolean), () => "One or more services failed to start");
   logger?.log("All services started successfully.");
   return result;
 }, "initServices");
@@ -1897,7 +1983,7 @@ var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
 
 // src/runCLI.ts
 var configuration;
-var version = isDefined17("1.16.20") ? "1.16.20" : "unknown";
+var version = isDefined17("1.16.22") ? "1.16.22" : "unknown";
 var getContextFromConfig = /* @__PURE__ */ __name((configuration2) => {
   const logger = initLogger(configuration2);
   const orchestrator = new Orchestrator(logger);
@@ -2039,6 +2125,7 @@ export {
   initEvmProvider,
   initHead,
   initHealthEndpoints,
+  initMemoryChainService,
   initPendingTransactions,
   initServices,
   initStakeIntentService,