@xyo-network/chain-orchestration 1.19.7 → 1.19.9

package/dist/neutral/index.mjs

@@ -1,166 +1,40 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/actor/BalanceActor.ts
-import { assertEx } from "@xylabs/sdk-js";
-import { Actor } from "@xyo-network/xl1-sdk";
-import { Mutex } from "async-mutex";
-var BalanceActor = class extends Actor {
-  static {
-    __name(this, "BalanceActor");
-  }
-  _updateMutex = new Mutex();
-  get accountBalanceViewer() {
-    return assertEx(this.params.accountBalanceViewer, () => "balanceService not set");
-  }
-  get blockViewer() {
-    return assertEx(this.params.blockViewer, () => "blockViewer not set");
-  }
-  async startHandler() {
-    await super.startHandler();
-    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.accountBalanceViewer.accountBalances([], {
-        head
-      });
-    });
-  }
-};
-
-// src/actor/MempoolActor.ts
-import { assertEx as assertEx2, creatable } from "@xylabs/sdk-js";
-import { Actor as Actor2 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex2 } 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;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-var MempoolActor = class extends Actor2 {
-  static {
-    __name(this, "MempoolActor");
-  }
-  _blockTimerId = null;
-  _blockTimerMutex = new Mutex2();
-  _transactionTimerId = null;
-  _transactionTimerMutex = new Mutex2();
-  get mempoolRunner() {
-    return this.params.mempoolRunner;
-  }
-  get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist;
-  }
-  get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist;
-  }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      mempoolRunner: assertEx2(params?.mempoolRunner, () => "mempoolRunner is required for MempoolActor"),
-      pendingBlocksArchivist: assertEx2(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required for MempoolActor"),
-      pendingTransactionsArchivist: assertEx2(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required for MempoolActor")
-    };
-  }
-  async startHandler() {
-    await super.startHandler();
-    this.restartBlockTimer();
-  }
-  async stopHandler() {
-    await super.stopHandler();
-    this.stopBlockTimer();
-  }
-  restartBlockTimer() {
-    this.stopBlockTimer();
-    this._blockTimerId = setInterval(() => {
-      if (this._blockTimerMutex.isLocked()) {
-        return;
-      }
-      void this._blockTimerMutex.runExclusive(async () => {
-        await this.mempoolRunner.prunePendingBlocks({
-          batchSize: 50
-        });
-      });
-    }, 1e3);
-  }
-  restartTransactionTimer() {
-    this.stopTransactionTimer();
-    this._transactionTimerId = setInterval(() => {
-      if (this._transactionTimerMutex.isLocked()) {
-        return;
-      }
-      void this._transactionTimerMutex.runExclusive(async () => {
-        await this.mempoolRunner.prunePendingTransactions({
-          batchSize: 50
-        });
-      });
-    }, 1e3);
-  }
-  stopBlockTimer() {
-    if (this._blockTimerId !== null) {
-      clearInterval(this._blockTimerId);
-    }
-    this._blockTimerId = null;
-  }
-  stopTransactionTimer() {
-    if (this._transactionTimerId !== null) {
-      clearInterval(this._transactionTimerId);
-    }
-    this._transactionTimerId = null;
-  }
-};
-MempoolActor = _ts_decorate([
-  creatable()
-], MempoolActor);
-
 // src/actor/ValidatorActor.ts
-import { assertEx as assertEx3, creatable as creatable2 } from "@xylabs/sdk-js";
+import { creatable } from "@xylabs/sdk-js";
 import { processPendingBlocks } from "@xyo-network/chain-sdk";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { Actor as Actor3 } from "@xyo-network/xl1-sdk";
-function _ts_decorate2(decorators, target, key, desc) {
+import { ActorV3, BlockViewerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate2, "_ts_decorate");
-var ValidatorActor = class extends Actor3 {
+__name(_ts_decorate, "_ts_decorate");
+var ValidatorActor = class extends ActorV3 {
   static {
     __name(this, "ValidatorActor");
   }
+  _blockViewer;
+  _finalizationRunner;
   _lastValidatedBlock;
   _lastValidatedBlockHash;
+  _mempoolViewer;
   get blockViewer() {
-    return this.params.blockViewer;
+    return this._blockViewer;
   }
-  get finalizedArchivist() {
-    return assertEx3(this.params.finalizedArchivist, () => "finalizedArchivist not set");
+  get finalizationRunner() {
+    return this._finalizationRunner;
   }
   get mempoolViewer() {
-    return this.params.mempoolViewer;
+    return this._mempoolViewer;
   }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      mempoolViewer: assertEx3(params?.mempoolViewer, () => "mempoolViewer is required for ValidatorActor"),
-      blockViewer: assertEx3(params?.blockViewer, () => "blockViewer is required for ValidatorActor"),
-      finalizedArchivist: assertEx3(params?.finalizedArchivist, () => "finalizedArchivist is required for ValidatorActor"),
-      account: assertEx3(params?.account, () => "account is required for ValidatorActor")
-    };
+  async createHandler() {
+    await super.startHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+    this._finalizationRunner = await this.locator.getInstance(FinalizationRunnerMoniker);
+    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker);
   }
   async startHandler() {
     await super.startHandler();
@@ -174,7 +48,7 @@ var ValidatorActor = class extends Actor3 {
             logger: this.logger,
             mempoolViewer: this.mempoolViewer,
             blockViewer: this.blockViewer,
-            finalizedArchivist: this.finalizedArchivist
+            finalizationRunner: this.finalizationRunner
           });
         }, {
           ...this.context,
@@ -186,28 +60,18 @@ var ValidatorActor = class extends Actor3 {
       /* 500 */
     );
   }
-  async slashInvalidBlock(_block) {
-    const slashed = await Promise.resolve(true);
-    return slashed;
-  }
-  async validateBlock(block) {
-    const valid = await Promise.resolve(true);
-    this._lastValidatedBlock = block;
-    this._lastValidatedBlockHash = await PayloadBuilder.hash(block);
-    return valid;
-  }
 };
-ValidatorActor = _ts_decorate2([
-  creatable2()
+ValidatorActor = _ts_decorate([
+  creatable()
 ], ValidatorActor);
 
 // src/archivists/ChainFinalized/archivist.ts
 import { startupSpanAsync } from "@xyo-network/chain-utils";
 import { timeBudget } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex4 } from "async-mutex";
+import { Mutex as Mutex2 } from "async-mutex";
 
 // src/archivists/ChainFinalized/local.ts
-import { Mutex as Mutex3 } from "async-mutex";
+import { Mutex } from "async-mutex";
 
 // src/archivists/lib/localPersistentArchivist.ts
 import { rm } from "fs/promises";
@@ -235,7 +99,7 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeNam
 }, "getLocalPersistentArchivist");
 
 // src/archivists/ChainFinalized/local.ts
-var mutex = new Mutex3();
+var mutex = new Mutex();
 var singleton;
 var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex.runExclusive(async () => {
@@ -247,7 +111,7 @@ var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config })
 }, "initLocalChainFinalizedArchivist");
 
 // src/archivists/ChainFinalized/archivist.ts
-var mutex2 = new Mutex4();
+var mutex2 = new Mutex2();
 var singleton2;
 async function initChainFinalizedArchivist(context) {
   return await mutex2.runExclusive(async () => {
@@ -264,11 +128,11 @@ __name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
 // src/archivists/PendingBlocks/archivist.ts
 import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
 import { timeBudget as timeBudget2 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex6 } from "async-mutex";
+import { Mutex as Mutex4 } from "async-mutex";
 
 // src/archivists/PendingBlocks/local.ts
-import { Mutex as Mutex5 } from "async-mutex";
-var mutex3 = new Mutex5();
+import { Mutex as Mutex3 } from "async-mutex";
+var mutex3 = new Mutex3();
 var singleton3;
 var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex3.runExclusive(async () => {
@@ -280,7 +144,7 @@ var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config })
 }, "initLocalPendingBlocksArchivist");
 
 // src/archivists/PendingBlocks/archivist.ts
-var mutex4 = new Mutex6();
+var mutex4 = new Mutex4();
 var singleton4;
 async function initPendingBlocksArchivist(context) {
   return await mutex4.runExclusive(async () => {
@@ -297,12 +161,12 @@ __name(initPendingBlocksArchivist, "initPendingBlocksArchivist");
 // src/archivists/RejectedTransactions/archivist.ts
 import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
 import { timeBudget as timeBudget3 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex8 } from "async-mutex";
+import { Mutex as Mutex6 } from "async-mutex";
 
 // src/archivists/RejectedTransactions/local.ts
 import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex7 } from "async-mutex";
-var mutex5 = new Mutex7();
+import { Mutex as Mutex5 } from "async-mutex";
+var mutex5 = new Mutex5();
 var singleton5;
 var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
   return await mutex5.runExclusive(async () => {
@@ -320,7 +184,7 @@ var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () =>
 }, "initLocalRejectedTransactionsArchivist");
 
 // src/archivists/RejectedTransactions/archivist.ts
-var mutex6 = new Mutex8();
+var mutex6 = new Mutex6();
 var singleton6;
 async function initRejectedTransactionsArchivist(params) {
   return await mutex6.runExclusive(async () => {
@@ -335,27 +199,27 @@ async function initRejectedTransactionsArchivist(params) {
 __name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
 // src/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
 import { timeBudget as timeBudget4 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex10 } from "async-mutex";
+import { Mutex as Mutex8 } from "async-mutex";
 
 // src/archivists/StakeIntentState/local.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
-import { Mutex as Mutex9 } from "async-mutex";
-var mutex7 = new Mutex9();
+import { assertEx } from "@xylabs/sdk-js";
+import { Mutex as Mutex7 } from "async-mutex";
+var mutex7 = new Mutex7();
 var singleton7;
 var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config }) => {
   return await mutex7.runExclusive(async () => {
     if (singleton7) 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"));
+    return assertEx(singleton7, () => new Error("Failed to initialize stake intent state archivist"));
   });
 }, "initLocalStakeIntentStateArchivist");
 
 // src/archivists/StakeIntentState/archivist.ts
-var mutex8 = new Mutex10();
+var mutex8 = new Mutex8();
 var singleton8;
 var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
   return await mutex8.runExclusive(async () => {
@@ -363,7 +227,7 @@ var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
     return await timeBudget4("initStakeIntentStateArchivist", context.logger, async () => {
       const local = await startupSpanAsync4("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(context));
       singleton8 = local;
-      return assertEx5(singleton8, () => "StakeIntentStateArchivist is undefined");
+      return assertEx2(singleton8, () => "StakeIntentStateArchivist is undefined");
     }, 2e3, true);
   });
 }, "initStakeIntentStateArchivist");
@@ -401,12 +265,12 @@ async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, r
 __name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
 // src/evm/initChainId.ts
-import { assertEx as assertEx6, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx3, 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 = assertEx6(config.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx3(config.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -420,10 +284,10 @@ var getChainId = /* @__PURE__ */ __name((config) => {
 }, "getChainId");
 
 // src/evm/initEvmProvider.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 
 // src/evm/initInfuraProvider.ts
-import { assertEx as assertEx7, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx4, isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 var instance;
 var initInfuraProvider = /* @__PURE__ */ __name((config) => {
@@ -436,8 +300,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 = assertEx7(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx7(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  const projectId = assertEx4(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx4(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config),
     projectId,
@@ -446,7 +310,7 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
 }, "getInfuraProviderConfig");
 
 // src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx8, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5, isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   const providerConfig = getJsonRpcProviderConfig(config);
@@ -456,7 +320,7 @@ var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined3(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx8(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx5(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config)
@@ -472,7 +336,7 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
   } else if (canUseJsonRpcProvider(config)) {
     provider = initJsonRpcProvider(config);
   }
-  return assertEx9(await provider, () => "No provider available");
+  return assertEx6(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
@@ -530,7 +394,7 @@ var createHealthServer = /* @__PURE__ */ __name((port, statusMonitor, logger) =>
 }, "createHealthServer");
 var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
   const { config, logger, statusReporter } = params;
-  const { healthCheckPort } = config.producer;
+  const { healthCheckPort } = config.actors.producer;
   return isDefined4(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
 }, "initHealthEndpoints");
 
@@ -575,7 +439,7 @@ var ServiceLifetime = {
 
 // src/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 import { MongoMap } from "@xyo-network/chain-protocol";
 import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
 async function initBalanceSummaryMap({ config, logger }) {
@@ -600,7 +464,7 @@ async function initBalanceSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx10(await result.start(), () => "Failed to start transfer summary map");
+    assertEx7(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -610,18 +474,18 @@ async function initBalanceSummaryMap({ config, logger }) {
 __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/init/initBridgedModule.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance } from "@xyo-network/archivist-model";
 import { asAttachableModuleInstance } from "@xyo-network/module-model";
-import { Mutex as Mutex11 } from "async-mutex";
-var initMutex = new Mutex11();
+import { Mutex as Mutex9 } from "async-mutex";
+var initMutex = new Mutex9();
 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 = assertEx11(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx11(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    const mod = assertEx8(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx8(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
     let moduleMap = bridgedModuleDictionary[bridge.address];
     if (moduleMap === void 0) {
       moduleMap = {};
@@ -632,22 +496,22 @@ var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) =>
   });
 }, "initBridgedModule");
 var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return assertEx11(asAttachableArchivistInstance(await initBridgedModule({
+  return assertEx8(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
 }, "initBridgedArchivistModule");
 
 // src/init/initEvmProvidersIfAvailable.ts
-import { asEthAddress, assertEx as assertEx12 } from "@xylabs/sdk-js";
-import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
-import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeViewer, SimpleTimeSyncViewer, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
+import { asEthAddress, assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
+import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
 async function initEvmProvidersIfAvailable(locator) {
   const { config, logger } = locator.context;
   if (canUseEvmProvider({
     config
   })) {
-    const chainId = assertEx12(config.chain.id, () => "Missing config.chain.chainId (required for EVM providers)");
+    const chainId = assertEx9(config.chain.id, () => "Missing config.chain.chainId (required for EVM providers)");
     const provider2 = await initEvmProvider({
       config,
       logger
@@ -661,6 +525,10 @@ async function initEvmProvidersIfAvailable(locator) {
       address,
       provider: provider2
     }));
+    locator.register(EvmStakeTotalsViewer.factory(EvmStakeTotalsViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
     locator.register(EvmChainContractViewer.factory(EvmChainContractViewer.dependencies, {
       address,
       provider: provider2
@@ -671,13 +539,14 @@ async function initEvmProvidersIfAvailable(locator) {
   } else {
     logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
     const positions = [];
-    const chainId = assertEx12(config.chain.id, () => "Missing config.chain.chainId (required for non-EVM providers)");
+    const chainId = assertEx9(config.chain.id, () => "Missing config.chain.chainId (required for non-EVM providers)");
     locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {
       positions
     }));
     locator.register(SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, {
       positions
     }));
+    locator.register(SimpleStakeTotalsViewer.factory(SimpleStakeTotalsViewer.dependencies, {}));
     locator.register(SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
       chainId,
       minWithdrawalBlocks: 10,
@@ -690,6 +559,33 @@ async function initEvmProvidersIfAvailable(locator) {
 }
 __name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
+// src/init/initFinalizationArchivistIfNeeded.ts
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { Account } from "@xyo-network/account";
+import { createBootstrapHead } from "@xyo-network/chain-sdk";
+import { asAttoXL1, findMostRecentBlock, flattenHydratedBlock } from "@xyo-network/xl1-sdk";
+async function initFinalizationArchivistIfNeeded(archivist, config, account) {
+  const configuredChainId = config.chain.id;
+  const possibleHead = await findMostRecentBlock(archivist);
+  if (configuredChainId && possibleHead && possibleHead.chain !== configuredChainId) {
+    throw new Error(`Configured chain ID (${configuredChainId}) does not match the existing chain ID (${possibleHead.chain})`);
+  }
+  let possibleChainId = configuredChainId;
+  if (!possibleHead) {
+    possibleChainId = possibleChainId ?? (await Account.random()).address;
+    const chain = await createBootstrapHead(account, possibleChainId, asAttoXL1(20000000000000000000000n), config.chain.genesisRewardAddress ?? account.address);
+    const payloads = chain.flatMap((block) => flattenHydratedBlock(block));
+    await archivist.insert(payloads);
+  }
+  const head = possibleHead ?? assertEx10(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
+  const chainId = assertEx10(possibleChainId, () => "Chain ID could not be determined");
+  return [
+    head,
+    chainId
+  ];
+}
+__name(initFinalizationArchivistIfNeeded, "initFinalizationArchivistIfNeeded");
+
 // src/init/initFinalizedArchivist.ts
 import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
 async function initMongoFinalizedArchivist(config) {
@@ -715,7 +611,7 @@ import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1
 var accountServiceSingleton;
 var initProducerAccount = /* @__PURE__ */ __name(async ({ config, logger }) => {
   if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config.producer.mnemonic;
+  let walletPhrase = config.actors.producer.mnemonic;
   if (isUndefined(walletPhrase)) {
     logger?.warn("[Producer] No wallet mnemonic specified!");
     const randomMnemonic = HDWallet.generateMnemonic();
@@ -733,12 +629,12 @@ ${randomMnemonic}
 }, "initProducerAccount");
 
 // src/init/initSeedPhrase.ts
-import { assertEx as assertEx13, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, 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");
   logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`);
-  const { mnemonic } = config.api;
+  const { mnemonic } = config.actors.api;
   if (isString(storedSeedPhrase) && isString(mnemonic)) {
     logger?.warn("[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.");
     await bios.seedPhraseStore.set("os", mnemonic);
@@ -753,12 +649,12 @@ async function initSeedPhrase({ config, logger, bios }) {
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx13(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx11(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }
 __name(initSeedPhrase, "initSeedPhrase");
 
 // src/init/initServerNode.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 
 // src/manifest/getLocator.ts
@@ -994,7 +890,7 @@ async function writableChainArchivistFromNode(node) {
 }
 __name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx14(asArchivistInstance(await node.resolve("Chain:Validated"), {
+  return assertEx12(asArchivistInstance(await node.resolve("Chain:Validated"), {
     required: true
   }));
 }
@@ -1019,7 +915,7 @@ async function initServerNode({ wallet, logger, config, node: providedNode, tran
     transfersSummaryMap,
     balancesSummaryMap
   });
-  assertEx14(await node.start(), () => "Failed to start node");
+  assertEx12(await node.start(), () => "Failed to start node");
   const writableChainArchivist = await writableChainArchivistFromNode(node);
   const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
   const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
@@ -1055,7 +951,7 @@ __name(initStatusReporter, "initStatusReporter");
 
 // src/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { assertEx as assertEx15 } from "@xylabs/sdk-js";
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
 import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-sdk";
 async function initTransferSummaryMap({ config, logger }) {
@@ -1080,7 +976,7 @@ async function initTransferSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx15(await result.start(), () => "Failed to start transfer summary map");
+    assertEx13(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1104,15 +1000,23 @@ async function initWallet({ config, logger }, mnemonic) {
 }
 __name(initWallet, "initWallet");
 async function initApiWallet({ config, logger }) {
-  const { mnemonic } = config.api;
+  const { mnemonic } = config.actors.api;
   return await initWallet({
     config,
     logger
   }, mnemonic);
 }
 __name(initApiWallet, "initApiWallet");
+async function initBridgeWallet({ config, logger }) {
+  const { mnemonic } = config.actors.bridge;
+  return await initWallet({
+    config,
+    logger
+  }, mnemonic);
+}
+__name(initBridgeWallet, "initBridgeWallet");
 async function initMempoolWallet({ config, logger }) {
-  const { mnemonic } = config.mempool;
+  const { mnemonic } = config.actors.mempool;
   return await initWallet({
     config,
     logger
@@ -1120,7 +1024,7 @@ async function initMempoolWallet({ config, logger }) {
 }
 __name(initMempoolWallet, "initMempoolWallet");
 async function initProducerWallet({ config, logger }) {
-  const { mnemonic } = config.producer;
+  const { mnemonic } = config.actors.producer;
   return await initWallet({
     config,
     logger
@@ -1128,23 +1032,31 @@ async function initProducerWallet({ config, logger }) {
 }
 __name(initProducerWallet, "initProducerWallet");
 async function initRewardsRedemptionApiWallet({ config, logger }) {
-  const { mnemonic } = config.rewardRedemptionApi;
+  const { mnemonic } = config.actors.rewardRedemption;
   return await initWallet({
     config,
     logger
   }, mnemonic);
 }
 __name(initRewardsRedemptionApiWallet, "initRewardsRedemptionApiWallet");
+async function initValidatorWallet({ config, logger }) {
+  const { mnemonic } = config.actors.mempool;
+  return await initWallet({
+    config,
+    logger
+  }, mnemonic);
+}
+__name(initValidatorWallet, "initValidatorWallet");
 
 // src/orchestrator/Orchestrator.ts
-import { AbstractCreatable, creatable as creatable3 } from "@xylabs/sdk-js";
-function _ts_decorate3(decorators, target, key, desc) {
+import { AbstractCreatable, creatable as creatable2 } from "@xylabs/sdk-js";
+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);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate3, "_ts_decorate");
+__name(_ts_decorate2, "_ts_decorate");
 var Orchestrator = class extends AbstractCreatable {
   static {
     __name(this, "Orchestrator");
@@ -1197,14 +1109,12 @@ var Orchestrator = class extends AbstractCreatable {
     this.logger?.log("[Orchestrator] Stopped...");
   }
 };
-Orchestrator = _ts_decorate3([
-  creatable3()
+Orchestrator = _ts_decorate2([
+  creatable2()
 ], Orchestrator);
 export {
-  BalanceActor,
   DefaultServiceProvider,
   GenericHost,
-  MempoolActor,
   NodeManifest,
   Orchestrator,
   PrivateChildManifests,
@@ -1223,11 +1133,13 @@ export {
   getLocator,
   initApiWallet,
   initBalanceSummaryMap,
+  initBridgeWallet,
   initBridgedArchivistModule,
   initBridgedModule,
   initChainFinalizedArchivist,
   initEvmProvider,
   initEvmProvidersIfAvailable,
+  initFinalizationArchivistIfNeeded,
   initFinalizedArchivist,
   initHealthEndpoints,
   initInfuraProvider,
@@ -1243,6 +1155,7 @@ export {
   initStakeIntentStateArchivist,
   initStatusReporter,
   initTransferSummaryMap,
+  initValidatorWallet,
   loadNode
 };
 //# sourceMappingURL=index.mjs.map