@xyo-network/chain-orchestration 1.17.7 → 1.18.0

package/dist/neutral/index.mjs

@@ -2,7 +2,8 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/actor/Actor.ts
-import { AbstractCreatable, Base, creatable, delay, IdLogger } from "@xylabs/sdk-js";
+import { AbstractCreatable, assertEx, Base, creatable, delay, IdLogger } from "@xylabs/sdk-js";
+import { getDefaultConfig, ProviderFactoryLocator } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore } from "async-mutex";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -25,6 +26,18 @@ var Actor = class extends AbstractCreatable {
   get id() {
     return this.params.id;
   }
+  get account() {
+    return this.params.account;
+  }
+  get config() {
+    return this.context.config;
+  }
+  get context() {
+    return this.params.context;
+  }
+  get locator() {
+    return this.context.locator;
+  }
   get logPrefix() {
     return `[${this.displayName} (${this.id})] `;
   }
@@ -32,11 +45,25 @@ var Actor = class extends AbstractCreatable {
     const baseParams = await super.paramsHandler(params);
     const id = params?.id ?? baseParams.name;
     const displayName = params?.displayName ?? baseParams.name;
+    const account = assertEx(params?.account, () => `Account is required for actor ${id}.`);
+    const logger = baseParams.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `);
+    const singletons = params?.context?.singletons ?? {};
+    const config = params?.context?.config ?? getDefaultConfig();
+    const context = params?.context ?? {
+      config,
+      locator: new ProviderFactoryLocator({
+        config,
+        logger,
+        singletons
+      })
+    };
     return {
       ...baseParams,
+      account,
+      context,
       displayName,
       id,
-      logger: baseParams.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `)
+      logger
     };
   }
   /**
@@ -69,6 +96,7 @@ var Actor = class extends AbstractCreatable {
             }
           }).catch((error) => {
             this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`);
+            this.logger?.error(error.stack);
           }).finally(() => {
             release();
             running = false;
@@ -124,7 +152,7 @@ Actor = _ts_decorate([
 ], Actor);
 
 // src/actor/BalanceActor.ts
-import { assertEx } from "@xylabs/sdk-js";
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { Mutex } from "async-mutex";
 var BalanceActor = class extends Actor {
   static {
@@ -132,10 +160,10 @@ var BalanceActor = class extends Actor {
   }
   _updateMutex = new Mutex();
   get balanceService() {
-    return assertEx(this.params.balance, () => "balanceService not set");
+    return assertEx2(this.params.balance, () => "balanceService not set");
   }
   get blockViewer() {
-    return assertEx(this.params.blockViewer, () => "blockViewer not set");
+    return assertEx2(this.params.blockViewer, () => "blockViewer not set");
   }
   async startHandler() {
     await super.startHandler();
@@ -153,15 +181,18 @@ var BalanceActor = class extends Actor {
     if (this._updateMutex.isLocked()) return;
     await this._updateMutex.runExclusive(async () => {
       const head = await this.blockViewer.currentBlockHash();
-      await this.balanceService.accountBalances([], head);
+      await this.balanceService.accountBalances([], {
+        head
+      });
     });
   }
 };
 
 // src/actor/ValidatorActor.ts
-import { assertEx as assertEx2, creatable as creatable2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx3, creatable as creatable2 } from "@xylabs/sdk-js";
 import { processPendingBlocks } from "@xyo-network/chain-sdk";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { BlockViewerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-protocol-sdk";
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -173,38 +204,24 @@ var ValidatorActor = class extends Actor {
   static {
     __name(this, "ValidatorActor");
   }
+  _blockViewer;
   _lastValidatedBlock;
   _lastValidatedBlockHash;
-  get account() {
-    return assertEx2(this.params.account, () => "account not set");
-  }
-  get balanceService() {
-    return assertEx2(this.params.balance, () => "balanceService not set");
-  }
+  _mempoolViewer;
   get blockViewer() {
-    return assertEx2(this.params.blockViewer, () => "blockViewer not set");
+    return this._blockViewer;
   }
-  get chainStakeViewer() {
-    return assertEx2(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+  get finalizedArchivist() {
+    return assertEx3(this.params.finalizedArchivist, () => "finalizedArchivist not set");
   }
   get mempoolViewer() {
-    return assertEx2(this.params.mempoolViewer, () => "mempoolViewer not set");
+    return this._mempoolViewer;
   }
-  get pendingBlocksArchivist() {
-    return assertEx2(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist not set");
+  async createHandler() {
+    await super.createHandler();
+    this._blockViewer = assertEx3(this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker), () => "Unable to locate a BlockViewer");
+    this._mempoolViewer = assertEx3(this.params.mempoolViewer ?? await this.locator.getInstance(MempoolViewerMoniker), () => "Unable to locate a MempoolViewer");
   }
-  // protected get chainSubmissionsArchivistWrite() {
-  //   return assertEx(this.params.chainSubmissionsArchivistWrite, () => 'chainSubmissionsArchivistWrite not set')
-  // }
-  // protected get pendingBundledTransactionsArchivistWrite() {
-  //   return assertEx(this.params.pendingBundledTransactionsArchivistWrite, () => 'pendingBundledTransactionsArchivistWrite not set')
-  // }
-  // protected get stakeIntentService() {
-  //   return assertEx(this.params.stakeIntent, () => 'stakeIntentService not set')
-  // }
-  // protected get validator() {
-  //   return assertEx(this.params.validator, () => 'validator not set')
-  // }
   async startHandler() {
     await super.startHandler();
     this.registerTimer(
@@ -213,10 +230,11 @@ var ValidatorActor = class extends Actor {
         await this.spanAsync("processPendingBlocks", async () => {
           console.log("ValidatorActor: Processing pending blocks...");
           await processPendingBlocks({
+            context: this.context,
             logger: this.logger,
             mempoolViewer: this.mempoolViewer,
             blockViewer: this.blockViewer,
-            chainArchivist: this.pendingBlocksArchivist
+            finalizedArchivist: this.finalizedArchivist
           });
         });
       },
@@ -288,14 +306,11 @@ var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config })
 // src/archivists/ChainFinalized/archivist.ts
 var mutex2 = new Mutex3();
 var singleton2;
-async function initChainFinalizedArchivist({ config, logger }) {
+async function initChainFinalizedArchivist(context) {
   return await mutex2.runExclusive(async () => {
     if (singleton2) return singleton2;
-    return await timeBudget("initChainFinalizedArchivist", logger, async () => {
-      const local = await startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
-        config,
-        logger
-      }));
+    return await timeBudget("initChainFinalizedArchivist", context.logger, async () => {
+      const local = await startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist(context));
       singleton2 = local;
       return singleton2;
     }, 2e3, true);
@@ -324,14 +339,11 @@ var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config })
 // src/archivists/PendingBlocks/archivist.ts
 var mutex4 = new Mutex5();
 var singleton4;
-async function initPendingBlocksArchivist({ config, logger }) {
+async function initPendingBlocksArchivist(context) {
   return await mutex4.runExclusive(async () => {
     if (singleton4) return singleton4;
-    return await timeBudget2("initPendingBlocksArchivist", logger, async () => {
-      const local = await startupSpanAsync2("PendingBlocksArchivist:initLocal", () => initLocalPendingBlocksArchivist({
-        config,
-        logger
-      }));
+    return await timeBudget2("initPendingBlocksArchivist", context.logger, async () => {
+      const local = await startupSpanAsync2("PendingBlocksArchivist:initLocal", () => initLocalPendingBlocksArchivist(context));
       singleton4 = local;
       return singleton4;
     }, 2e3, true);
@@ -339,112 +351,76 @@ async function initPendingBlocksArchivist({ config, logger }) {
 }
 __name(initPendingBlocksArchivist, "initPendingBlocksArchivist");
 
-// src/archivists/PendingTransactions/archivist.ts
+// src/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 Mutex7 } from "async-mutex";
 
-// src/archivists/PendingTransactions/local.ts
+// src/archivists/RejectedTransactions/local.ts
+import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
 import { Mutex as Mutex6 } from "async-mutex";
 var mutex5 = new Mutex6();
 var singleton5;
-var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex5.runExclusive(async () => {
     if (singleton5) return singleton5;
-    const { root } = config.storage;
-    singleton5 = await getLocalPersistentArchivist("local-pending-transactions", "chain", "pending_transaction_bundles", root);
+    singleton5 = await MemoryArchivist.create({
+      account: "random",
+      config: {
+        schema: MemoryArchivistConfigSchema,
+        max: 1e3,
+        name: "localRejectedTransactions"
+      }
+    });
     return singleton5;
   });
-}, "initLocalPendingTransactionsArchivist");
+}, "initLocalRejectedTransactionsArchivist");
 
-// src/archivists/PendingTransactions/archivist.ts
+// src/archivists/RejectedTransactions/archivist.ts
 var mutex6 = new Mutex7();
 var singleton6;
-async function initPendingTransactionsArchivist({ config, logger }) {
+async function initRejectedTransactionsArchivist(params) {
   return await mutex6.runExclusive(async () => {
     if (singleton6) return singleton6;
-    return await timeBudget3("initPendingTransactionsArchivist", logger, async () => {
-      const local = await startupSpanAsync3("PendingTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist({
-        config,
-        logger
-      }));
+    return await timeBudget3("initRejectedTransactionsArchivist", params.logger, async () => {
+      const local = await startupSpanAsync3("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
       singleton6 = local;
       return singleton6;
     }, 2e3, true);
   });
 }
-__name(initPendingTransactionsArchivist, "initPendingTransactionsArchivist");
+__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
-// src/archivists/RejectedTransactions/archivist.ts
+// src/archivists/StakeIntentState/archivist.ts
+import { assertEx as assertEx5 } 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 Mutex9 } from "async-mutex";
 
-// src/archivists/RejectedTransactions/local.ts
-import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
+// src/archivists/StakeIntentState/local.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { Mutex as Mutex8 } from "async-mutex";
 var mutex7 = new Mutex8();
 var singleton7;
-var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex7.runExclusive(async () => {
     if (singleton7) return singleton7;
-    singleton7 = await MemoryArchivist.create({
-      account: "random",
-      config: {
-        schema: MemoryArchivistConfigSchema,
-        max: 1e3,
-        name: "localRejectedTransactions"
-      }
-    });
-    return singleton7;
+    const { root } = config.storage;
+    singleton7 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
+    return assertEx4(singleton7, () => new Error("Failed to initialize stake intent state archivist"));
   });
-}, "initLocalRejectedTransactionsArchivist");
+}, "initLocalStakeIntentStateArchivist");
 
-// src/archivists/RejectedTransactions/archivist.ts
+// src/archivists/StakeIntentState/archivist.ts
 var mutex8 = new Mutex9();
 var singleton8;
-async function initRejectedTransactionsArchivist(params) {
+var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
   return await mutex8.runExclusive(async () => {
     if (singleton8) return singleton8;
-    return await timeBudget4("initRejectedTransactionsArchivist", params.logger, async () => {
-      const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
+    return await timeBudget4("initStakeIntentStateArchivist", context.logger, async () => {
+      const local = await startupSpanAsync4("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(context));
       singleton8 = local;
-      return singleton8;
-    }, 2e3, true);
-  });
-}
-__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
-
-// src/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx4 } 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 Mutex11 } from "async-mutex";
-
-// src/archivists/StakeIntentState/local.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
-import { Mutex as Mutex10 } from "async-mutex";
-var mutex9 = new Mutex10();
-var singleton9;
-var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config }) => {
-  return await mutex9.runExclusive(async () => {
-    if (singleton9) return singleton9;
-    const { root } = config.storage;
-    singleton9 = await getLocalPersistentArchivist("local-stake-intent-state", "stakeIntent", "state", root);
-    return assertEx3(singleton9, () => new Error("Failed to initialize stake intent state archivist"));
-  });
-}, "initLocalStakeIntentStateArchivist");
-
-// src/archivists/StakeIntentState/archivist.ts
-var mutex10 = new Mutex11();
-var singleton10;
-var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (params) => {
-  return await mutex10.runExclusive(async () => {
-    if (singleton10) return singleton10;
-    return await timeBudget5("initStakeIntentStateArchivist", params.logger, async () => {
-      const local = await startupSpanAsync5("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(params));
-      singleton10 = local;
-      return assertEx4(singleton10, () => "StakeIntentStateArchivist is undefined");
+      return assertEx5(singleton8, () => "StakeIntentStateArchivist is undefined");
     }, 2e3, true);
   });
 }, "initStakeIntentStateArchivist");
@@ -469,7 +445,8 @@ function buildTelemetryConfig(config, serviceName, serviceVersion) {
 __name(buildTelemetryConfig, "buildTelemetryConfig");
 
 // src/createDeclarationIntentBlock.ts
-import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-sdk";
+import { buildNextBlock } from "@xyo-network/chain-sdk";
+import { createDeclarationIntent } from "@xyo-network/xl1-protocol-sdk";
 async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
   const producerDeclarationPayload = createDeclarationIntent(producerAccount.address, "producer", range[0], range[1]);
   return await buildNextBlock(prevBlock, [], [
@@ -481,19 +458,19 @@ async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, r
 __name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
 // src/evm/initEvmProvider.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
 
 // src/evm/initInfuraProvider.ts
-import { assertEx as assertEx6, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7, isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 
 // src/evm/initChainId.ts
-import { assertEx as assertEx5, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx6, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
 var canUseChainId = /* @__PURE__ */ __name((config) => {
   return isDefined(config.evm.chainId);
 }, "canUseChainId");
 var getChainId = /* @__PURE__ */ __name((config) => {
-  const chainId = assertEx5(config.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx6(config.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -518,8 +495,8 @@ var canUseInfuraProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined2(config.evm?.infura?.projectId) && isDefined2(config.evm?.infura?.projectSecret);
 }, "canUseInfuraProvider");
 var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
-  const projectId = assertEx6(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx6(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  const projectId = assertEx7(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx7(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config),
     projectId,
@@ -528,7 +505,7 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
 }, "getInfuraProviderConfig");
 
 // src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx7, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8, isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   const providerConfig = getJsonRpcProviderConfig(config);
@@ -538,7 +515,7 @@ var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined3(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx7(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx8(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config)
@@ -554,7 +531,7 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
   } else if (canUseJsonRpcProvider(config)) {
     provider = initJsonRpcProvider(config);
   }
-  return assertEx8(await provider, () => "No provider available");
+  return assertEx9(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
@@ -657,7 +634,7 @@ var ServiceLifetime = {
 
 // src/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
 import { MongoMap } from "@xyo-network/chain-protocol";
 import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-protocol-sdk";
 async function initBalanceSummaryMap({ config, logger }) {
@@ -682,7 +659,7 @@ async function initBalanceSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx9(await result.start(), () => "Failed to start transfer summary map");
+    assertEx10(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -692,18 +669,18 @@ async function initBalanceSummaryMap({ config, logger }) {
 __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/init/initBridgedModule.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance } from "@xyo-network/archivist-model";
 import { asAttachableModuleInstance } from "@xyo-network/module-model";
-import { Mutex as Mutex12 } from "async-mutex";
-var initMutex = new Mutex12();
+import { Mutex as Mutex10 } from "async-mutex";
+var initMutex = new Mutex10();
 var bridgedModuleDictionary = {};
 var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
   return await initMutex.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
-    const mod = assertEx10(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx10(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    const mod = assertEx11(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx11(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
     let moduleMap = bridgedModuleDictionary[bridge.address];
     if (moduleMap === void 0) {
       moduleMap = {};
@@ -714,60 +691,81 @@ var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) =>
   });
 }, "initBridgedModule");
 var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return assertEx10(asAttachableArchivistInstance(await initBridgedModule({
+  return assertEx11(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
 }, "initBridgedArchivistModule");
 
 // src/init/initChainStakeViewer.ts
-import { asAddress, assertEx as assertEx11, toAddress, toEthAddress } from "@xylabs/sdk-js";
-import { EthereumChainStakeEvents, EthereumChainStakeViewer } from "@xyo-network/chain-sdk";
+import { asAddress, assertEx as assertEx12, toAddress, toEthAddress } from "@xylabs/sdk-js";
+import { EthereumChainStakeEventsViewer, EthereumChainStakeViewer } from "@xyo-network/chain-sdk";
 import { StakedXyoChainV2__factory } from "@xyo-network/typechain";
-import { SimpleChainStakeViewer } from "@xyo-network/xl1-protocol-sdk";
-async function initEvmChainStakeViewer(config, logger) {
+import { SimpleStakeViewer } from "@xyo-network/xl1-protocol-sdk";
+async function initEvmChainStakeViewer(context, config, logger) {
   const provider2 = await initEvmProvider({
     config,
     logger
   });
-  const contractAddress = assertEx11(config.chain.id, () => "Missing config.evm.chainId");
+  const contractAddress = assertEx12(config.chain.id, () => "Missing config.evm.chainId");
   const contract = StakedXyoChainV2__factory.connect(toEthAddress(contractAddress), provider2);
-  const stakeEventsViewer = await EthereumChainStakeEvents.create({
+  const stakeEventsViewer = await EthereumChainStakeEventsViewer.create({
     contract,
-    logger
+    logger,
+    context
   });
-  assertEx11(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
+  assertEx12(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
   const stakeChainViewer = await EthereumChainStakeViewer.create({
     contract,
     stakeEventsViewer,
-    logger
+    logger,
+    context
   });
-  assertEx11(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
+  assertEx12(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
   return stakeChainViewer;
 }
 __name(initEvmChainStakeViewer, "initEvmChainStakeViewer");
-async function initSimpleStakeViewer(config, logger) {
-  const stakeChainViewer = await SimpleChainStakeViewer.create({
+async function initSimpleStakeViewer(context, config, logger) {
+  const stakeViewer = await SimpleStakeViewer.create({
+    context,
     chainId: asAddress(toAddress(1n), true),
     logger,
     positions: []
   });
-  assertEx11(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
-  return stakeChainViewer;
+  assertEx12(await stakeViewer.start(), () => "Failed to start SimpleChainStake viewer");
+  return stakeViewer;
 }
 __name(initSimpleStakeViewer, "initSimpleStakeViewer");
-async function initStakeViewer({ config, logger }) {
+async function initStakeViewer({ config, logger, context }) {
   if (canUseEvmProvider({
     config
   })) {
-    return await initEvmChainStakeViewer(config, logger);
+    return await initEvmChainStakeViewer(context, config, logger);
   } else {
     console.warn("[API] Infura configuration not found. Using SimpleChainStakeViewer with no positions. This means no staking data will be available.");
-    return await initSimpleStakeViewer(config, logger);
+    return await initSimpleStakeViewer(context, config, logger);
   }
 }
 __name(initStakeViewer, "initStakeViewer");
 
+// src/init/initFinalizedArchivist.ts
+import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
+async function initMongoFinalizedArchivist(config) {
+  const payloadSdkConfig = {
+    ...config.storage.mongo,
+    collection: "chain_validated"
+  };
+  return await MongoDBArchivistV2.create({
+    payloadSdkConfig
+  });
+}
+__name(initMongoFinalizedArchivist, "initMongoFinalizedArchivist");
+async function initFinalizedArchivist(config) {
+  const finalizedArchivist = await initMongoFinalizedArchivist(config);
+  return finalizedArchivist;
+}
+__name(initFinalizedArchivist, "initFinalizedArchivist");
+
 // src/init/initProducerAccount.ts
 import { isUndefined } from "@xylabs/sdk-js";
 import { HDWallet } from "@xyo-network/wallet";
@@ -793,7 +791,7 @@ ${randomMnemonic}
 }, "initProducerAccount");
 
 // src/init/initSeedPhrase.ts
-import { assertEx as assertEx12, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx13, isString } from "@xylabs/sdk-js";
 import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
 async function initSeedPhrase({ config, logger, bios }) {
   const storedSeedPhrase = await bios.seedPhraseStore.get("os");
@@ -813,18 +811,18 @@ async function initSeedPhrase({ config, logger, bios }) {
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx12(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx13(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }
 __name(initSeedPhrase, "initSeedPhrase");
 
 // src/init/initServerNode.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 
 // src/manifest/getLocator.ts
 import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 import { MemoryArchivist as MemoryArchivist2 } from "@xyo-network/archivist-memory";
-import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
+import { MongoDBArchivistV2 as MongoDBArchivistV22 } from "@xyo-network/archivist-mongodb";
 import { ViewArchivist } from "@xyo-network/archivist-view";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
 import { AbstractModule, LoggerModuleStatusReporter } from "@xyo-network/module-abstract";
@@ -864,7 +862,7 @@ var getLocator = /* @__PURE__ */ __name(async ({ config, logger }) => {
       statusReporter,
       traceProvider
     };
-    locator.register(MongoDBArchivistV2.factory(params), void 0, true);
+    locator.register(MongoDBArchivistV22.factory(params), void 0, true);
   }
   locator.register(MemoryArchivist2.factory({
     traceProvider,
@@ -1046,7 +1044,7 @@ async function writableChainArchivistFromNode(node) {
 }
 __name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx13(asArchivistInstance(await node.resolve("Chain:Validated"), {
+  return assertEx14(asArchivistInstance(await node.resolve("Chain:Validated"), {
     required: true
   }));
 }
@@ -1071,6 +1069,7 @@ async function initServerNode({ wallet, logger, config, node: providedNode, tran
     transfersSummaryMap,
     balancesSummaryMap
   });
+  assertEx14(await node.start(), () => "Failed to start node");
   const writableChainArchivist = await writableChainArchivistFromNode(node);
   const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
   const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
@@ -1101,97 +1100,8 @@ async function initServerWallet({ config, logger }) {
 }
 __name(initServerWallet, "initServerWallet");
 
-// src/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/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/init/initStatusReporter.ts
+import { RuntimeStatusMonitor } from "@xyo-network/xl1-protocol-sdk";
 function initStatusReporter({ logger }) {
   const statusReporter = new RuntimeStatusMonitor(logger);
   statusReporter.onGlobalTransition({
@@ -1211,7 +1121,7 @@ __name(initStatusReporter, "initStatusReporter");
 
 // src/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx15 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
 import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-protocol-sdk";
 async function initTransferSummaryMap({ config, logger }) {
@@ -1236,7 +1146,7 @@ async function initTransferSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx14(await result.start(), () => "Failed to start transfer summary map");
+    assertEx15(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1245,34 +1155,6 @@ async function initTransferSummaryMap({ config, logger }) {
 }
 __name(initTransferSummaryMap, "initTransferSummaryMap");
 
-// src/init/iterator.ts
-import { BaseElectionService, ChainBlockNumberIterationService, XyoStakeIntentService } from "@xyo-network/chain-services";
-import { timeBudget as timeBudget6 } from "@xyo-network/xl1-protocol-sdk";
-var chainIteratorServiceSingleton;
-var stakeIntentServiceSingleton;
-var electionServiceSingleton;
-var initChainIterator = /* @__PURE__ */ __name((params) => {
-  if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton;
-  return timeBudget6("initChainIterator", params.logger, () => {
-    chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
-    return chainIteratorServiceSingleton;
-  }, 2e3, true);
-}, "initChainIterator");
-var initStakeIntentService = /* @__PURE__ */ __name((params) => {
-  if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
-  return timeBudget6("initStakeIntentService", params.logger, () => {
-    stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
-    return stakeIntentServiceSingleton;
-  }, 2e3, true);
-}, "initStakeIntentService");
-var initElectionService = /* @__PURE__ */ __name((params) => {
-  if (electionServiceSingleton) return electionServiceSingleton;
-  return timeBudget6("initElectionService", params.logger, () => {
-    electionServiceSingleton = BaseElectionService.create(params);
-    return electionServiceSingleton;
-  }, 2e3, true);
-}, "initElectionService");
-
 // src/orchestrator/Orchestrator.ts
 import { AbstractCreatable as AbstractCreatable2, creatable as creatable3 } from "@xylabs/sdk-js";
 function _ts_decorate3(decorators, target, key, desc) {
@@ -1342,12 +1224,10 @@ export {
   BalanceActor,
   DefaultServiceProvider,
   GenericHost,
-  LoggerStatusReporter,
   NodeManifest,
   Orchestrator,
   PrivateChildManifests,
   PublicChildManifests,
-  RuntimeStatusMonitor,
   ServiceLifetime,
   ValidatorActor,
   buildTelemetryConfig,
@@ -1358,20 +1238,17 @@ export {
   initBridgedArchivistModule,
   initBridgedModule,
   initChainFinalizedArchivist,
-  initChainIterator,
-  initElectionService,
   initEvmChainStakeViewer,
   initEvmProvider,
+  initFinalizedArchivist,
   initHealthEndpoints,
   initPendingBlocksArchivist,
-  initPendingTransactionsArchivist,
   initProducerAccount,
   initRejectedTransactionsArchivist,
   initSeedPhrase,
   initServerNode,
   initServerWallet,
   initSimpleStakeViewer,
-  initStakeIntentService,
   initStakeIntentStateArchivist,
   initStakeViewer,
   initStatusReporter,