@xyo-network/chain-orchestration 1.17.2 → 1.17.3

package/dist/neutral/index.mjs

@@ -123,126 +123,350 @@ Actor = _ts_decorate([
   creatable()
 ], Actor);
 
-// src/archivist/initArchivistSync.ts
-import { ArchivistSyncDiviner } from "@xyo-network/chain-modules";
-import { DivinerConfigSchema } from "@xyo-network/diviner-model";
-import { MemoryNode } from "@xyo-network/node-memory";
-import { MemorySentinel } from "@xyo-network/sentinel-memory";
-import { SentinelConfigSchema } from "@xyo-network/sentinel-model";
-var initArchivistSync = /* @__PURE__ */ __name(async (name, inArchivist, outArchivist, frequency = 1e3, max = 1e3, traceProvider) => {
-  const node = await MemoryNode.create({
-    account: "random"
-  });
-  const finalizedArchivistSyncDiviner = await ArchivistSyncDiviner.create({
-    account: "random",
-    inArchivist,
-    outArchivist,
-    traceProvider,
-    config: {
-      schema: DivinerConfigSchema,
-      name,
-      max
-    }
-  });
-  await node.register(finalizedArchivistSyncDiviner);
-  await node.attach(finalizedArchivistSyncDiviner.address);
-  const sentinel = await MemorySentinel.create({
-    account: "random",
-    config: {
-      name,
-      synchronous: true,
-      schema: SentinelConfigSchema,
-      tasks: [
-        {
-          required: true,
-          mod: finalizedArchivistSyncDiviner.address,
-          endPoint: "divine"
-        }
-      ],
-      automations: [
-        {
-          frequency,
-          frequencyUnits: "millis",
-          schema: "network.xyo.automation.interval",
-          start: Date.now(),
-          type: "interval"
+// src/actor/BalanceActor.ts
+import { assertEx } from "@xylabs/sdk-js";
+import { Mutex } from "async-mutex";
+var BalanceActor = class extends Actor {
+  static {
+    __name(this, "BalanceActor");
+  }
+  _updateMutex = new Mutex();
+  get balanceService() {
+    return assertEx(this.params.balance, () => "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.balanceService.accountBalances([], head);
+    });
+  }
+};
+
+// src/actor/ValidatorActor.ts
+import { assertEx as assertEx2, creatable as creatable2 } from "@xylabs/sdk-js";
+import { processPendingBlocks } from "@xyo-network/chain-sdk";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+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_decorate2, "_ts_decorate");
+var ValidatorActor = class extends Actor {
+  static {
+    __name(this, "ValidatorActor");
+  }
+  _lastValidatedBlock;
+  _lastValidatedBlockHash;
+  get account() {
+    return assertEx2(this.params.account, () => "account not set");
+  }
+  get balanceService() {
+    return assertEx2(this.params.balance, () => "balanceService not set");
+  }
+  get blockViewer() {
+    return assertEx2(this.params.blockViewer, () => "blockViewer not set");
+  }
+  get chainStakeViewer() {
+    return assertEx2(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+  }
+  get mempoolViewer() {
+    return assertEx2(this.params.mempoolViewer, () => "mempoolViewer not set");
+  }
+  get pendingBlocksArchivist() {
+    return assertEx2(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist not set");
+  }
+  // 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(
+      "ValidatorActor",
+      async () => {
+        await this.spanAsync("processPendingBlocks", async () => {
+          console.log("ValidatorActor: Processing pending blocks...");
+          await processPendingBlocks({
+            logger: this.logger,
+            mempoolViewer: this.mempoolViewer,
+            blockViewer: this.blockViewer,
+            chainArchivist: this.pendingBlocksArchivist
+          });
+        });
+      },
+      2e3,
+      1500
+      /* 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);
+
+// src/archivists/ChainFinalized/archivist.ts
+import { startupSpanAsync } from "@xyo-network/chain-utils";
+import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex3 } from "async-mutex";
+
+// src/archivists/ChainFinalized/local.ts
+import { Mutex as Mutex2 } from "async-mutex";
+
+// src/archivists/lib/localPersistentArchivist.ts
+import { rm } from "fs/promises";
+import Path from "path";
+import { LmdbArchivist, LmdbArchivistConfigSchema } from "@xyo-network/archivist-lmdb";
+import { getStoreDirectory } from "@xyo-network/chain-protocol";
+var DEFAULT_STORAGE_ROOT = Path.join(process.cwd(), ".store");
+var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeName, storageRoot, kind = "lmdb") => {
+  switch (kind) {
+    case "lmdb": {
+      const root = storageRoot ?? DEFAULT_STORAGE_ROOT;
+      return LmdbArchivist.create({
+        account: "random",
+        config: {
+          name,
+          clearStoreOnStart: false,
+          dbName,
+          location: getStoreDirectory(dbName, root, "lmdb"),
+          schema: LmdbArchivistConfigSchema,
+          storeName
         }
-      ]
+      });
     }
+  }
+}, "getLocalPersistentArchivist");
+
+// src/archivists/ChainFinalized/local.ts
+var mutex = new Mutex2();
+var singleton;
+var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+  return await mutex.runExclusive(async () => {
+    if (singleton) return singleton;
+    const { root } = config.storage;
+    singleton = await getLocalPersistentArchivist("local-finalized-chain", "chain", "finalized", root);
+    return singleton;
   });
-  await node.register(sentinel);
-  await node.attach(sentinel.address);
-  return node;
-}, "initArchivistSync");
+}, "initLocalChainFinalizedArchivist");
 
-// src/archivist/wrapWithReadCachingArchivist.ts
-import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-var DefaultReadCachingArchivistConfig = {
-  max: 1e5,
-  // requireAllParents: true,
-  schema: MemoryArchivistConfigSchema
-};
-var getDynamicDefaultReadCachingArchivistConfig = /* @__PURE__ */ __name((archivist) => {
-  const { id } = archivist;
-  const name = `${id}-CachingArchivist`;
-  const dynamicDefaults = {
-    name
-  };
-  return dynamicDefaults;
-}, "getDynamicDefaultReadCachingArchivistConfig");
-var getDynamicReadCachingArchivistConfig = /* @__PURE__ */ __name((_archivist) => {
-  const dynamicConfig = {};
-  return dynamicConfig;
-}, "getDynamicReadCachingArchivistConfig");
-var wrapWithReadCachingArchivist = /* @__PURE__ */ __name(async (archivist, config = DefaultReadCachingArchivistConfig) => {
-  const dynamicDefaultReadCachingArchivistConfig = getDynamicDefaultReadCachingArchivistConfig(archivist);
-  const dynamicReadCachingArchivistConfig = getDynamicReadCachingArchivistConfig(archivist);
-  const materializedConfig = {
-    // Use the static defaults
-    ...DefaultReadCachingArchivistConfig,
-    // Use the dynamic defaults
-    ...dynamicDefaultReadCachingArchivistConfig,
-    // Use the supplied config
-    ...config,
-    // Use they dynamic config
-    ...dynamicReadCachingArchivistConfig
-  };
-  const cachingArchivist = await MemoryArchivist.create({
-    account: "random",
-    config: materializedConfig
+// src/archivists/ChainFinalized/archivist.ts
+var mutex2 = new Mutex3();
+var singleton2;
+async function initChainFinalizedArchivist({ config, logger }) {
+  return await mutex2.runExclusive(async () => {
+    if (singleton2) return singleton2;
+    return await timeBudget("initChainFinalizedArchivist", logger, async () => {
+      const local = await startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist({
+        config,
+        logger
+      }));
+      singleton2 = local;
+      return singleton2;
+    }, 2e3, true);
   });
-  await initArchivistSync(`${cachingArchivist.id}-Sync`, archivist, cachingArchivist, 1e3);
-  return cachingArchivist;
-}, "wrapWithReadCachingArchivist");
+}
+__name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
 
-// src/bridge.ts
-import { HttpBridge, HttpBridgeConfigSchema } from "@xyo-network/bridge-http";
-import { Mutex } from "async-mutex";
-var initMutex = new Mutex();
-var bridgeSingletonMap = /* @__PURE__ */ new Map();
-var initBridge = /* @__PURE__ */ __name(async (nodeUrl) => {
-  return await initMutex.runExclusive(async () => {
-    const existing = bridgeSingletonMap.get(nodeUrl);
-    if (existing) return existing;
-    const bridge = await HttpBridge.create({
+// src/archivists/PendingBlocks/archivist.ts
+import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
+import { timeBudget as timeBudget2 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex5 } from "async-mutex";
+
+// src/archivists/PendingBlocks/local.ts
+import { Mutex as Mutex4 } from "async-mutex";
+var mutex3 = new Mutex4();
+var singleton3;
+var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+  return await mutex3.runExclusive(async () => {
+    if (singleton3) return singleton3;
+    const { root } = config.storage;
+    singleton3 = await getLocalPersistentArchivist("local-pending-blocks", "chain", "pending_block_bundles", root);
+    return singleton3;
+  });
+}, "initLocalPendingBlocksArchivist");
+
+// src/archivists/PendingBlocks/archivist.ts
+var mutex4 = new Mutex5();
+var singleton4;
+async function initPendingBlocksArchivist({ config, logger }) {
+  return await mutex4.runExclusive(async () => {
+    if (singleton4) return singleton4;
+    return await timeBudget2("initPendingBlocksArchivist", logger, async () => {
+      const local = await startupSpanAsync2("PendingBlocksArchivist:initLocal", () => initLocalPendingBlocksArchivist({
+        config,
+        logger
+      }));
+      singleton4 = local;
+      return singleton4;
+    }, 2e3, true);
+  });
+}
+__name(initPendingBlocksArchivist, "initPendingBlocksArchivist");
+
+// src/archivists/PendingTransactions/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
+import { Mutex as Mutex6 } from "async-mutex";
+var mutex5 = new Mutex6();
+var singleton5;
+var initLocalPendingTransactionsArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+  return await mutex5.runExclusive(async () => {
+    if (singleton5) return singleton5;
+    const { root } = config.storage;
+    singleton5 = await getLocalPersistentArchivist("local-pending-transactions", "chain", "pending_transaction_bundles", root);
+    return singleton5;
+  });
+}, "initLocalPendingTransactionsArchivist");
+
+// src/archivists/PendingTransactions/archivist.ts
+var mutex6 = new Mutex7();
+var singleton6;
+async function initPendingTransactionsArchivist({ config, logger }) {
+  return await mutex6.runExclusive(async () => {
+    if (singleton6) return singleton6;
+    return await timeBudget3("initPendingTransactionsArchivist", logger, async () => {
+      const local = await startupSpanAsync3("PendingTransactionsArchivist:initLocal", () => initLocalPendingTransactionsArchivist({
+        config,
+        logger
+      }));
+      singleton6 = local;
+      return singleton6;
+    }, 2e3, true);
+  });
+}
+__name(initPendingTransactionsArchivist, "initPendingTransactionsArchivist");
+
+// src/archivists/RejectedTransactions/archivist.ts
+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";
+import { Mutex as Mutex8 } from "async-mutex";
+var mutex7 = new Mutex8();
+var singleton7;
+var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+  return await mutex7.runExclusive(async () => {
+    if (singleton7) return singleton7;
+    singleton7 = await MemoryArchivist.create({
       account: "random",
       config: {
-        name: "HttpBridge",
-        client: {
-          url: nodeUrl,
-          discoverRoots: "start"
-        },
-        schema: HttpBridgeConfigSchema,
-        security: {
-          allowAnonymous: true
-        }
+        schema: MemoryArchivistConfigSchema,
+        max: 1e3,
+        name: "localRejectedTransactions"
       }
     });
-    await bridge.start();
-    bridgeSingletonMap.set(nodeUrl, bridge);
-    return bridge;
+    return singleton7;
+  });
+}, "initLocalRejectedTransactionsArchivist");
+
+// src/archivists/RejectedTransactions/archivist.ts
+var mutex8 = new Mutex9();
+var singleton8;
+async function initRejectedTransactionsArchivist(params) {
+  return await mutex8.runExclusive(async () => {
+    if (singleton8) return singleton8;
+    return await timeBudget4("initRejectedTransactionsArchivist", params.logger, async () => {
+      const local = await startupSpanAsync4("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
+      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");
+    }, 2e3, true);
   });
-}, "initBridge");
+}, "initStakeIntentStateArchivist");
+
+// src/buildTelemetryConfig.ts
+function buildTelemetryConfig(config, serviceName, serviceVersion) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9464 } = config.telemetry?.metrics?.scrape ?? {};
+  const telemetryConfig = {
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  };
+  return telemetryConfig;
+}
+__name(buildTelemetryConfig, "buildTelemetryConfig");
 
 // src/createDeclarationIntentBlock.ts
 import { buildNextBlock, createDeclarationIntent } from "@xyo-network/chain-sdk";
@@ -256,91 +480,20 @@ async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, r
 }
 __name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
-// src/init/initBalanceSummaryMap.ts
-import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx } 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 }) {
-  const mongoConfig = config.storage?.mongo;
-  if (hasMongoConfig(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
-    const payloadSdkConfig = {
-      dbConnectionString,
-      dbDomain,
-      dbName,
-      dbPassword,
-      dbUserName
-    };
-    const sdkBalanceSummaryMap = new BaseMongoSdk({
-      ...payloadSdkConfig,
-      collection: "balance_summary_map"
-    });
-    const result = await MongoMap.create({
-      sdk: sdkBalanceSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
-    });
-    assertEx(await result.start(), () => "Failed to start transfer summary map");
-    return result;
-  } else {
-    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
-    return new MemoryMap();
-  }
-}
-__name(initBalanceSummaryMap, "initBalanceSummaryMap");
-
-// src/init/initBridgedModule.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-import { asAttachableArchivistInstance } from "@xyo-network/archivist-model";
-import { asAttachableModuleInstance } from "@xyo-network/module-model";
-import { Mutex as Mutex2 } from "async-mutex";
-var initMutex2 = new Mutex2();
-var bridgedModuleDictionary = {};
-var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return await initMutex2.runExclusive(async () => {
-    const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
-    if (existing) return existing;
-    const mod = assertEx2(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx2(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
-    let moduleMap = bridgedModuleDictionary[bridge.address];
-    if (moduleMap === void 0) {
-      moduleMap = {};
-      bridgedModuleDictionary[bridge.address] = moduleMap;
-    }
-    moduleMap[moduleName] = moduleInstance;
-    return moduleInstance;
-  });
-}, "initBridgedModule");
-var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return assertEx2(asAttachableArchivistInstance(await initBridgedModule({
-    bridge,
-    moduleName
-  })), () => `Could not convert ${moduleName} to attachable archivist instance`);
-}, "initBridgedArchivistModule");
-
-// src/init/initChainStakeViewer.ts
-import { asAddress, assertEx as assertEx7, toAddress, toEthAddress } from "@xylabs/sdk-js";
-import { EthereumChainStakeEvents, EthereumChainStakeViewer } from "@xyo-network/chain-sdk";
-import { StakedXyoChainV2__factory } from "@xyo-network/typechain";
-import { SimpleChainStakeViewer } from "@xyo-network/xl1-protocol-sdk";
-
 // src/evm/initEvmProvider.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
 
 // src/evm/initInfuraProvider.ts
-import { assertEx as assertEx4, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6, isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 
 // src/evm/initChainId.ts
-import { assertEx as assertEx3, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx5, 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 = assertEx3(config.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx5(config.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -365,8 +518,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 = assertEx4(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx4(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  const projectId = assertEx6(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx6(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config),
     projectId,
@@ -375,7 +528,7 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
 }, "getInfuraProviderConfig");
 
 // src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx5, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7, isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   const providerConfig = getJsonRpcProviderConfig(config);
@@ -385,7 +538,7 @@ var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined3(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx5(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx7(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config)
@@ -401,31 +554,195 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
   } else if (canUseJsonRpcProvider(config)) {
     provider = initJsonRpcProvider(config);
   }
-  return assertEx6(await provider, () => "No provider available");
+  return assertEx8(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
 }, "canUseEvmProvider");
 
+// src/health/initHealthEndpoints.ts
+import http from "http";
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+var sendStatus = /* @__PURE__ */ __name((res, status, errorCode) => {
+  const statusCode = status === "started" ? 200 : errorCode;
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json"
+  });
+  res.end(JSON.stringify({
+    status
+  }));
+}, "sendStatus");
+var notFound = /* @__PURE__ */ __name((res) => {
+  res.writeHead(404, {
+    "Content-Type": "application/json"
+  });
+  res.end(JSON.stringify({
+    status: "not found"
+  }));
+}, "notFound");
+var createHealthServer = /* @__PURE__ */ __name((port, statusMonitor, logger) => {
+  const server = http.createServer((req, res) => {
+    const url = req.url ?? "";
+    const status = statusMonitor.getGlobalStatus();
+    switch (url) {
+      case "/healthz": {
+        sendStatus(res, status, 500);
+        break;
+      }
+      case "/livez": {
+        sendStatus(res, status, 503);
+        break;
+      }
+      case "/readyz": {
+        sendStatus(res, status, 503);
+        break;
+      }
+      default: {
+        notFound(res);
+      }
+    }
+  });
+  server.listen(port, () => {
+    logger.log(`Health server running on http://localhost:${port}`);
+    logger.log(" - /healthz");
+    logger.log(" - /livez");
+    logger.log(" - /readyz");
+  });
+  return server;
+}, "createHealthServer");
+var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
+  const { config, logger, statusReporter } = params;
+  const { healthCheckPort } = config.producer;
+  return isDefined4(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
+}, "initHealthEndpoints");
+
+// src/host/implementation/DefaultHost.ts
+var GenericHost = class {
+  static {
+    __name(this, "GenericHost");
+  }
+  services;
+  constructor(services) {
+    this.services = services;
+  }
+  async start() {
+    await Promise.resolve();
+    console.log("Host is starting...");
+  }
+  async stop() {
+    await Promise.resolve();
+    console.log("Host is stopping...");
+  }
+};
+
+// src/host/implementation/DefaultServiceProvider.ts
+var DefaultServiceProvider = class {
+  static {
+    __name(this, "DefaultServiceProvider");
+  }
+  _services;
+  constructor(services) {
+    this._services = services;
+  }
+  getService(serviceIdentifier) {
+    return this._services[serviceIdentifier];
+  }
+};
+
+// src/host/model/ServiceCollection.ts
+var ServiceLifetime = {
+  Singleton: "Singleton",
+  Transient: "Transient"
+};
+
+// src/init/initBalanceSummaryMap.ts
+import { BaseMongoSdk } from "@xylabs/mongo";
+import { assertEx as assertEx9 } 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 }) {
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const sdkBalanceSummaryMap = new BaseMongoSdk({
+      ...payloadSdkConfig,
+      collection: "balance_summary_map"
+    });
+    const result = await MongoMap.create({
+      sdk: sdkBalanceSummaryMap,
+      getCache: {
+        enabled: true,
+        maxEntries: 5e3
+      }
+    });
+    assertEx9(await result.start(), () => "Failed to start transfer summary map");
+    return result;
+  } else {
+    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
+    return new MemoryMap();
+  }
+}
+__name(initBalanceSummaryMap, "initBalanceSummaryMap");
+
+// src/init/initBridgedModule.ts
+import { assertEx as assertEx10 } 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();
+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`);
+    let moduleMap = bridgedModuleDictionary[bridge.address];
+    if (moduleMap === void 0) {
+      moduleMap = {};
+      bridgedModuleDictionary[bridge.address] = moduleMap;
+    }
+    moduleMap[moduleName] = moduleInstance;
+    return moduleInstance;
+  });
+}, "initBridgedModule");
+var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
+  return assertEx10(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 { StakedXyoChainV2__factory } from "@xyo-network/typechain";
+import { SimpleChainStakeViewer } from "@xyo-network/xl1-protocol-sdk";
 async function initEvmChainStakeViewer(config, logger) {
   const provider2 = await initEvmProvider({
     config,
     logger
   });
-  const contractAddress = assertEx7(config.chain.id, () => "Missing config.evm.chainId");
+  const contractAddress = assertEx11(config.chain.id, () => "Missing config.evm.chainId");
   const contract = StakedXyoChainV2__factory.connect(toEthAddress(contractAddress), provider2);
   const stakeEventsViewer = await EthereumChainStakeEvents.create({
     contract,
     logger
   });
-  assertEx7(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
+  assertEx11(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
   const stakeChainViewer = await EthereumChainStakeViewer.create({
     contract,
     stakeEventsViewer,
     logger
   });
-  assertEx7(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
+  assertEx11(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
   return stakeChainViewer;
 }
 __name(initEvmChainStakeViewer, "initEvmChainStakeViewer");
@@ -435,11 +752,11 @@ async function initSimpleStakeViewer(config, logger) {
     logger,
     positions: []
   });
-  assertEx7(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
+  assertEx11(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
   return stakeChainViewer;
 }
 __name(initSimpleStakeViewer, "initSimpleStakeViewer");
-async function initStakeViewer(config, logger) {
+async function initStakeViewer({ config, logger }) {
   if (canUseEvmProvider({
     config
   })) {
@@ -451,64 +768,6 @@ async function initStakeViewer(config, logger) {
 }
 __name(initStakeViewer, "initStakeViewer");
 
-// src/init/initPendingBlockArchivist.ts
-import { MemoryArchivist as MemoryArchivist2 } from "@xyo-network/archivist-memory";
-import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
-import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-protocol-sdk";
-async function initPendingBlockArchivist({ config, logger }) {
-  const mongoConfig = config.storage?.mongo;
-  if (hasMongoConfig2(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
-    const payloadSdkConfig = {
-      dbConnectionString,
-      dbDomain,
-      dbName,
-      dbPassword,
-      dbUserName
-    };
-    return await MongoDBArchivistV2.create({
-      payloadSdkConfig: {
-        ...payloadSdkConfig,
-        collection: "pending_block_bundles"
-      },
-      logger
-    });
-  } else {
-    logger?.warn("[API] Mongo configuration not found. Using MemoryArchivist for TransferSummaryMap.");
-    return await MemoryArchivist2.create();
-  }
-}
-__name(initPendingBlockArchivist, "initPendingBlockArchivist");
-
-// src/init/initPendingTransactionArchivist.ts
-import { MemoryArchivist as MemoryArchivist3 } from "@xyo-network/archivist-memory";
-import { MongoDBArchivistV2 as MongoDBArchivistV22 } from "@xyo-network/archivist-mongodb";
-import { hasMongoConfig as hasMongoConfig3 } from "@xyo-network/xl1-protocol-sdk";
-async function initPendingTransactionArchivist({ config, logger }) {
-  const mongoConfig = config.storage?.mongo;
-  if (hasMongoConfig3(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
-    const payloadSdkConfig = {
-      dbConnectionString,
-      dbDomain,
-      dbName,
-      dbPassword,
-      dbUserName
-    };
-    return await MongoDBArchivistV22.create({
-      payloadSdkConfig: {
-        ...payloadSdkConfig,
-        collection: "pending_transaction_bundles"
-      },
-      logger
-    });
-  } else {
-    logger?.warn("[API] Mongo configuration not found. Using MemoryArchivist for TransferSummaryMap.");
-    return await MemoryArchivist3.create();
-  }
-}
-__name(initPendingTransactionArchivist, "initPendingTransactionArchivist");
-
 // src/init/initProducerAccount.ts
 import { isUndefined } from "@xylabs/sdk-js";
 import { HDWallet } from "@xyo-network/wallet";
@@ -534,7 +793,7 @@ ${randomMnemonic}
 }, "initProducerAccount");
 
 // src/init/initSeedPhrase.ts
-import { assertEx as assertEx8, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx12, 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");
@@ -554,28 +813,25 @@ async function initSeedPhrase({ config, logger, bios }) {
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx8(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx12(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }
 __name(initSeedPhrase, "initSeedPhrase");
 
 // src/init/initServerNode.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 
 // src/manifest/getLocator.ts
-import { asAddress as asAddress2, assertEx as assertEx9, isDefined as isDefined4, ZERO_ADDRESS } from "@xylabs/sdk-js";
-import { MemoryArchivist as MemoryArchivist4 } from "@xyo-network/archivist-memory";
-import { MongoDBArchivistV2 as MongoDBArchivistV23 } from "@xyo-network/archivist-mongodb";
+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 { ViewArchivist } from "@xyo-network/archivist-view";
-import { AddressBalanceDivinerV2, AddressTransferDiviner, ArchivistSyncDiviner as ArchivistSyncDiviner2, HeadValidationDiviner } from "@xyo-network/chain-modules";
 import { initTelemetry } from "@xyo-network/chain-telemetry";
 import { AbstractModule, LoggerModuleStatusReporter } from "@xyo-network/module-abstract";
 import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
-import { MemorySentinel as MemorySentinel2 } from "@xyo-network/sentinel-memory";
-import { StepSizes } from "@xyo-network/xl1-protocol";
-import { hasMongoConfig as hasMongoConfig4 } from "@xyo-network/xl1-protocol-sdk";
-import { Semaphore as Semaphore2 } from "async-mutex";
-var getLocator = /* @__PURE__ */ __name(async ({ config, logger, balancesSummaryMap, transfersSummaryMap }) => {
+import { MemorySentinel } from "@xyo-network/sentinel-memory";
+import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-protocol-sdk";
+var getLocator = /* @__PURE__ */ __name(async ({ config, logger }) => {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = 9465 } = config.telemetry?.metrics?.scrape ?? {};
   const { traceProvider, meterProvider } = await initTelemetry({
@@ -589,11 +845,11 @@ var getLocator = /* @__PURE__ */ __name(async ({ config, logger, balancesSummary
       port
     }
   });
-  if (isDefined4(logger)) AbstractModule.defaultLogger = logger;
+  if (isDefined5(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
-  if (hasMongoConfig4(mongoConfig)) {
+  if (hasMongoConfig2(mongoConfig)) {
     const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
@@ -608,36 +864,14 @@ var getLocator = /* @__PURE__ */ __name(async ({ config, logger, balancesSummary
       statusReporter,
       traceProvider
     };
-    locator.register(MongoDBArchivistV23.factory(params), void 0, true);
+    locator.register(MongoDBArchivistV2.factory(params), void 0, true);
   }
-  locator.register(AddressBalanceDivinerV2.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter,
-    summaryMap: balancesSummaryMap,
-    stepSemaphores: StepSizes.map(() => new Semaphore2(20))
-  }));
-  locator.register(AddressTransferDiviner.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter,
-    summaryMap: transfersSummaryMap,
-    stepSemaphores: StepSizes.map(() => new Semaphore2(20))
-  }));
-  const chainId = isDefined4(config.chain.id) ? assertEx9(asAddress2(config.chain.id), () => "chain.id must be an Address") : ZERO_ADDRESS;
-  locator.register(HeadValidationDiviner.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter,
-    chainId,
-    allowedProducers: config.producer.allowlist
-  }));
-  locator.register(MemoryArchivist4.factory({
+  locator.register(MemoryArchivist2.factory({
     traceProvider,
     meterProvider,
     statusReporter
   }));
-  locator.register(MemorySentinel2.factory({
+  locator.register(MemorySentinel.factory({
     traceProvider,
     meterProvider,
     statusReporter
@@ -647,11 +881,6 @@ var getLocator = /* @__PURE__ */ __name(async ({ config, logger, balancesSummary
     meterProvider,
     statusReporter
   }));
-  locator.register(ArchivistSyncDiviner2.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
   return locator;
 }, "getLocator");
 
@@ -683,7 +912,7 @@ var NodeManifest = node_default;
 // src/manifest/private/index.ts
 var PrivateChildManifests = [];
 
-// src/manifest/public/WithMempool/Chain.json
+// src/manifest/public/Chain.json
 var Chain_default = {
   $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
   nodes: [
@@ -708,108 +937,12 @@ var Chain_default = {
               },
               schema: "network.xyo.archivist.config"
             }
-          },
-          {
-            config: {
-              accountPath: "1/1'/2'",
-              schema: "network.xyo.diviner.chain.head.validation.config",
-              eventSubscriptions: [
-                {
-                  sourceEvent: "inserted",
-                  sourceModule: "Submissions",
-                  targetModuleFunction: "divine"
-                }
-              ],
-              inArchivist: "Submissions",
-              outArchivist: "Validated",
-              name: "HeadValidationDiviner"
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1'/3'",
-              automations: [
-                {
-                  frequency: 1e3,
-                  frequencyUnits: "millis",
-                  schema: "network.xyo.automation.interval",
-                  type: "interval"
-                }
-              ],
-              name: "ChainValidationSentinel",
-              schema: "network.xyo.sentinel.config",
-              synchronous: true,
-              tasks: [
-                {
-                  mod: "HeadValidationDiviner",
-                  endPoint: "divine"
-                }
-              ]
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1'/4'",
-              automations: [
-                {
-                  frequency: 1e4,
-                  frequencyUnits: "millis",
-                  schema: "network.xyo.automation.interval",
-                  type: "interval"
-                }
-              ],
-              name: "AddressBalancePollingSentinel",
-              schema: "network.xyo.sentinel.config",
-              synchronous: true,
-              tasks: [
-                {
-                  mod: "AddressBalanceDiviner",
-                  endPoint: "divine"
-                }
-              ]
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1'/5'",
-              automations: [
-                {
-                  frequency: 1e4,
-                  frequencyUnits: "millis",
-                  schema: "network.xyo.automation.interval",
-                  type: "interval"
-                }
-              ],
-              name: "AddressTransferPollingSentinel",
-              schema: "network.xyo.sentinel.config",
-              synchronous: true,
-              tasks: [
-                {
-                  mod: "AddressTransferDiviner",
-                  endPoint: "divine"
-                }
-              ]
-            }
           }
         ],
         public: [
           {
             config: {
               accountPath: "1/1/1",
-              name: "Submissions",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              payloadSdkConfig: {
-                collection: "chain_submissions"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1/2",
               name: "Finalized",
               allowedQueries: [
                 "network.xyo.query.archivist.get",
@@ -822,36 +955,6 @@ var Chain_default = {
               originArchivist: "Validated",
               schema: "network.xyo.archivist.view.config"
             }
-          },
-          {
-            config: {
-              accountPath: "1/1/3'",
-              name: "AddressBalanceDiviner",
-              schema: "network.xyo.diviner.chain.address.balance.config",
-              map: {
-                lmdb: {
-                  dbName: "summaries",
-                  storeName: "address_balance",
-                  location: ".store"
-                }
-              },
-              archivist: "Validated"
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1/4'",
-              name: "AddressTransferDiviner",
-              schema: "network.xyo.diviner.chain.address.transfer.config",
-              map: {
-                lmdb: {
-                  dbName: "summaries",
-                  storeName: "address_transfer",
-                  location: ".store"
-                }
-              },
-              archivist: "Validated"
-            }
           }
         ]
       }
@@ -860,7 +963,7 @@ var Chain_default = {
   schema: "network.xyo.manifest"
 };
 
-// src/manifest/public/WithMempool/Pending.json
+// src/manifest/public/Pending.json
 var Pending_default = {
   $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
   nodes: [
@@ -876,7 +979,7 @@ var Pending_default = {
           {
             config: {
               accountPath: "2/1/1",
-              name: "PendingTransactions",
+              name: "Transactions",
               getCache: {
                 enabled: true,
                 maxEntries: 5e3
@@ -893,7 +996,7 @@ var Pending_default = {
           {
             config: {
               accountPath: "2/1/2",
-              name: "PendingBlocks",
+              name: "Blocks",
               getCache: {
                 enabled: true,
                 maxEntries: 5e3
@@ -911,176 +1014,16 @@ var Pending_default = {
   schema: "network.xyo.manifest"
 };
 
-// src/manifest/public/WithMempool/index.ts
+// src/manifest/public/index.ts
 var ChainNodeManifest = Chain_default;
 var PendingNodeManifest = Pending_default;
-var PublicChildManifestsWithMempool = [
+var PublicChildManifests = [
   ...ChainNodeManifest.nodes,
   ...PendingNodeManifest.nodes
 ];
 
-// src/manifest/public/WithoutMempool/Chain.json
-var Chain_default2 = {
-  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  nodes: [
-    {
-      config: {
-        accountPath: "1",
-        name: "Chain",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [
-          {
-            config: {
-              accountPath: "1/1'/1'",
-              name: "Validated",
-              allowedQueries: [
-                "network.xyo.query.archivist.get",
-                "network.xyo.query.archivist.next"
-              ],
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              payloadSdkConfig: {
-                collection: "chain_validated"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          }
-        ],
-        public: [
-          {
-            config: {
-              accountPath: "1/1/1",
-              name: "Submissions",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              payloadSdkConfig: {
-                collection: "chain_submissions"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1/2",
-              name: "Finalized",
-              allowedQueries: [
-                "network.xyo.query.archivist.get",
-                "network.xyo.query.archivist.next"
-              ],
-              getCache: {
-                enabled: true,
-                maxEntries: 5e4
-              },
-              originArchivist: "Validated",
-              schema: "network.xyo.archivist.view.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1/3'",
-              name: "AddressBalanceDiviner",
-              schema: "network.xyo.diviner.chain.address.balance.config",
-              map: {
-                lmdb: {
-                  dbName: "summaries",
-                  storeName: "address_balance",
-                  location: ".store"
-                }
-              },
-              archivist: "Validated"
-            }
-          },
-          {
-            config: {
-              accountPath: "1/1/4'",
-              name: "AddressTransferDiviner",
-              schema: "network.xyo.diviner.chain.address.transfer.config",
-              map: {
-                lmdb: {
-                  dbName: "summaries",
-                  storeName: "address_transfer",
-                  location: ".store"
-                }
-              },
-              archivist: "Validated"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  schema: "network.xyo.manifest"
-};
-
-// src/manifest/public/WithoutMempool/Pending.json
-var Pending_default2 = {
-  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  nodes: [
-    {
-      config: {
-        accountPath: "2",
-        name: "Pending",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [],
-        public: [
-          {
-            config: {
-              accountPath: "2/1/1",
-              name: "PendingTransactions",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              labels: {
-                "network.xyo.storage.class": "mongodb"
-              },
-              payloadSdkConfig: {
-                collection: "pending_transaction_bundles"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "2/1/2",
-              name: "PendingBlocks",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              payloadSdkConfig: {
-                collection: "pending_block_bundles"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  schema: "network.xyo.manifest"
-};
-
-// src/manifest/public/WithoutMempool/index.ts
-var ChainNodeManifest2 = Chain_default2;
-var PendingNodeManifest2 = Pending_default2;
-var PublicChildManifestsWithoutMempool = [
-  ...ChainNodeManifest2.nodes,
-  ...PendingNodeManifest2.nodes
-];
-
 // src/manifest/loadNode.ts
 var loadNode = /* @__PURE__ */ __name(async ({ wallet, config, balancesSummaryMap, transfersSummaryMap }) => {
-  const { enabled: mempoolEnabled } = config.mempool;
-  const PublicChildManifests = mempoolEnabled ? PublicChildManifestsWithoutMempool : PublicChildManifestsWithMempool;
   const locator = await getLocator({
     config,
     balancesSummaryMap,
@@ -1096,20 +1039,30 @@ var loadNode = /* @__PURE__ */ __name(async ({ wallet, config, balancesSummaryMa
 }, "loadNode");
 
 // src/init/initServerNode.ts
-async function chainArchivistFromNode(node) {
-  const chainArchivist = assertEx10(asArchivistInstance(await node.resolve("Chain:Validated"), {
+async function writableChainArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("Chain:Validated"), {
+    required: true
+  });
+}
+__name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
+async function readonlyChainArchivistFromNode(node) {
+  return assertEx13(asArchivistInstance(await node.resolve("Chain:Validated"), {
+    required: true
+  }));
+}
+__name(readonlyChainArchivistFromNode, "readonlyChainArchivistFromNode");
+async function pendingTransactionsArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("XYOChain:Pending:Transactions"), {
     required: true
-  }), () => "FinalizedArchivist not found in node");
-  return chainArchivist;
+  });
 }
-__name(chainArchivistFromNode, "chainArchivistFromNode");
-async function pendingArchivistFromNode(node) {
-  const pendingArchivist = assertEx10(asArchivistInstance(await node.resolve("XYOChain:Pending:PendingTransactions"), {
+__name(pendingTransactionsArchivistFromNode, "pendingTransactionsArchivistFromNode");
+async function pendingBlocksArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("XYOChain:Pending:Blocks"), {
     required: true
-  }), () => "PendingArchivist not found in node");
-  return pendingArchivist;
+  });
 }
-__name(pendingArchivistFromNode, "pendingArchivistFromNode");
+__name(pendingBlocksArchivistFromNode, "pendingBlocksArchivistFromNode");
 async function initServerNode({ wallet, logger, config, node: providedNode, transfersSummaryMap, balancesSummaryMap }) {
   const node = providedNode ?? await loadNode({
     wallet,
@@ -1118,24 +1071,28 @@ async function initServerNode({ wallet, logger, config, node: providedNode, tran
     transfersSummaryMap,
     balancesSummaryMap
   });
-  const chainArchivist = await chainArchivistFromNode(node);
-  const pendingArchivist = await pendingArchivistFromNode(node);
+  const writableChainArchivist = await writableChainArchivistFromNode(node);
+  const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
+  const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
+  const pendingBlocksArchivist = await pendingBlocksArchivistFromNode(node);
   return {
     node,
-    chainArchivist,
-    pendingArchivist
+    writableChainArchivist,
+    readonlyChainArchivist,
+    pendingTransactionsArchivist,
+    pendingBlocksArchivist
   };
 }
 __name(initServerNode, "initServerNode");
 
 // src/init/initServerWallet.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { isDefined as isDefined6 } from "@xylabs/sdk-js";
 import { boot } from "@xyo-network/bios";
 import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
 async function initServerWallet({ config, logger }) {
   const { mnemonic } = config.api;
   const bios = await boot();
-  const seedPhrase = isDefined5(mnemonic) ? mnemonic : await initSeedPhrase({
+  const seedPhrase = isDefined6(mnemonic) ? mnemonic : await initSeedPhrase({
     bios,
     config,
     logger
@@ -1144,14 +1101,122 @@ 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
+function initStatusReporter({ logger }) {
+  const statusReporter = new RuntimeStatusMonitor(logger);
+  statusReporter.onGlobalTransition({
+    to: "started"
+  }, () => {
+    logger.log("All services started.");
+  });
+  statusReporter.onGlobalTransition({
+    to: "error"
+  }, () => {
+    logger.error("Producer encountered an unhandled error!");
+    process.exit(1);
+  });
+  return statusReporter;
+}
+__name(initStatusReporter, "initStatusReporter");
+
 // src/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
-import { hasMongoConfig as hasMongoConfig5, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-protocol-sdk";
+import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-protocol-sdk";
 async function initTransferSummaryMap({ config, logger }) {
   const mongoConfig = config.storage?.mongo;
-  if (hasMongoConfig5(mongoConfig)) {
+  if (hasMongoConfig3(mongoConfig)) {
     const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
@@ -1171,7 +1236,7 @@ async function initTransferSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx11(await result.start(), () => "Failed to start transfer summary map");
+    assertEx14(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1182,41 +1247,41 @@ __name(initTransferSummaryMap, "initTransferSummaryMap");
 
 // src/init/iterator.ts
 import { BaseElectionService, ChainBlockNumberIterationService, XyoStakeIntentService } from "@xyo-network/chain-services";
-import { timeBudget } from "@xyo-network/xl1-protocol-sdk";
+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 timeBudget("initChainIterator", params.logger, () => {
+  return timeBudget6("initChainIterator", params.logger, () => {
     chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params);
     return chainIteratorServiceSingleton;
   }, 2e3, true);
 }, "initChainIterator");
 var initStakeIntentService = /* @__PURE__ */ __name((params) => {
   if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton;
-  return timeBudget("initStakeIntentService", params.logger, () => {
+  return timeBudget6("initStakeIntentService", params.logger, () => {
     stakeIntentServiceSingleton = XyoStakeIntentService.create(params);
     return stakeIntentServiceSingleton;
   }, 2e3, true);
 }, "initStakeIntentService");
 var initElectionService = /* @__PURE__ */ __name((params) => {
   if (electionServiceSingleton) return electionServiceSingleton;
-  return timeBudget("initElectionService", params.logger, () => {
+  return timeBudget6("initElectionService", params.logger, () => {
     electionServiceSingleton = BaseElectionService.create(params);
     return electionServiceSingleton;
   }, 2e3, true);
 }, "initElectionService");
 
 // src/orchestrator/Orchestrator.ts
-import { AbstractCreatable as AbstractCreatable2, creatable as creatable2 } from "@xylabs/sdk-js";
-function _ts_decorate2(decorators, target, key, desc) {
+import { AbstractCreatable as AbstractCreatable2, creatable as creatable3 } from "@xylabs/sdk-js";
+function _ts_decorate3(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");
+__name(_ts_decorate3, "_ts_decorate");
 var Orchestrator = class extends AbstractCreatable2 {
   static {
     __name(this, "Orchestrator");
@@ -1269,38 +1334,48 @@ var Orchestrator = class extends AbstractCreatable2 {
     this.logger?.log("[Orchestrator] Stopped...");
   }
 };
-Orchestrator = _ts_decorate2([
-  creatable2()
+Orchestrator = _ts_decorate3([
+  creatable3()
 ], Orchestrator);
 export {
   Actor,
-  DefaultReadCachingArchivistConfig,
+  BalanceActor,
+  DefaultServiceProvider,
+  GenericHost,
+  LoggerStatusReporter,
   NodeManifest,
   Orchestrator,
   PrivateChildManifests,
-  PublicChildManifestsWithMempool,
-  PublicChildManifestsWithoutMempool,
+  PublicChildManifests,
+  RuntimeStatusMonitor,
+  ServiceLifetime,
+  ValidatorActor,
+  buildTelemetryConfig,
+  canUseEvmProvider,
   createProducerChainStakeIntentBlock,
   getLocator,
-  initArchivistSync,
   initBalanceSummaryMap,
-  initBridge,
   initBridgedArchivistModule,
   initBridgedModule,
+  initChainFinalizedArchivist,
   initChainIterator,
   initElectionService,
   initEvmChainStakeViewer,
-  initPendingBlockArchivist,
-  initPendingTransactionArchivist,
+  initEvmProvider,
+  initHealthEndpoints,
+  initPendingBlocksArchivist,
+  initPendingTransactionsArchivist,
   initProducerAccount,
+  initRejectedTransactionsArchivist,
   initSeedPhrase,
   initServerNode,
   initServerWallet,
   initSimpleStakeViewer,
   initStakeIntentService,
+  initStakeIntentStateArchivist,
   initStakeViewer,
+  initStatusReporter,
   initTransferSummaryMap,
-  loadNode,
-  wrapWithReadCachingArchivist
+  loadNode
 };
 //# sourceMappingURL=index.mjs.map