@xyo-network/chain-orchestration 1.19.17 → 1.20.0

package/dist/neutral/index.mjs

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/actor/ValidatorActor.ts
+// src/shared/actor/ValidatorActor.ts
 import { creatable } from "@xylabs/sdk-js";
 import { processPendingBlocks } from "@xyo-network/chain-sdk";
 import { ActorV3, BlockViewerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
@@ -65,178 +65,7 @@ ValidatorActor = _ts_decorate([
   creatable()
 ], ValidatorActor);
 
-// src/archivists/ChainFinalized/archivist.ts
-import { timeBudget } from "@xylabs/sdk-js";
-import { startupSpanAsync } from "@xyo-network/chain-utils";
-import { Mutex as Mutex2 } from "async-mutex";
-
-// src/archivists/ChainFinalized/local.ts
-import { Mutex } 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 Mutex();
-var singleton;
-async function initLocalChainFinalizedArchivist({ 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;
-  });
-}
-__name(initLocalChainFinalizedArchivist, "initLocalChainFinalizedArchivist");
-
-// src/archivists/ChainFinalized/archivist.ts
-var mutex2 = new Mutex2();
-var singleton2;
-async function initChainFinalizedArchivist(context) {
-  return await mutex2.runExclusive(async () => {
-    if (singleton2) return singleton2;
-    return await timeBudget("initChainFinalizedArchivist", context.logger, async () => {
-      const local = await startupSpanAsync("ChainFinalizedArchivist:initLocal", () => initLocalChainFinalizedArchivist(context));
-      singleton2 = local;
-      return singleton2;
-    }, 2e3, true);
-  });
-}
-__name(initChainFinalizedArchivist, "initChainFinalizedArchivist");
-
-// src/archivists/PendingBlocks/archivist.ts
-import { timeBudget as timeBudget2 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex4 } from "async-mutex";
-
-// src/archivists/PendingBlocks/local.ts
-import { Mutex as Mutex3 } from "async-mutex";
-var mutex3 = new Mutex3();
-var singleton3;
-async function initLocalPendingBlocksArchivist({ 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;
-  });
-}
-__name(initLocalPendingBlocksArchivist, "initLocalPendingBlocksArchivist");
-
-// src/archivists/PendingBlocks/archivist.ts
-var mutex4 = new Mutex4();
-var singleton4;
-async function initPendingBlocksArchivist(context) {
-  return await mutex4.runExclusive(async () => {
-    if (singleton4) return singleton4;
-    return await timeBudget2("initPendingBlocksArchivist", context.logger, async () => {
-      const local = await startupSpanAsync2("PendingBlocksArchivist:initLocal", () => initLocalPendingBlocksArchivist(context));
-      singleton4 = local;
-      return singleton4;
-    }, 2e3, true);
-  });
-}
-__name(initPendingBlocksArchivist, "initPendingBlocksArchivist");
-
-// src/archivists/RejectedTransactions/archivist.ts
-import { timeBudget as timeBudget3 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex6 } from "async-mutex";
-
-// src/archivists/RejectedTransactions/local.ts
-import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archivist-memory";
-import { Mutex as Mutex5 } from "async-mutex";
-var mutex5 = new Mutex5();
-var singleton5;
-async function initLocalRejectedTransactionsArchivist() {
-  return await mutex5.runExclusive(async () => {
-    if (singleton5) return singleton5;
-    singleton5 = await MemoryArchivist.create({
-      account: "random",
-      config: {
-        schema: MemoryArchivistConfigSchema,
-        max: 1e3,
-        name: "localRejectedTransactions"
-      }
-    });
-    return singleton5;
-  });
-}
-__name(initLocalRejectedTransactionsArchivist, "initLocalRejectedTransactionsArchivist");
-
-// src/archivists/RejectedTransactions/archivist.ts
-var mutex6 = new Mutex6();
-var singleton6;
-async function initRejectedTransactionsArchivist({ logger }) {
-  return await mutex6.runExclusive(async () => {
-    if (singleton6) return singleton6;
-    return await timeBudget3("initRejectedTransactionsArchivist", logger, async () => {
-      const local = await startupSpanAsync3("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist());
-      singleton6 = local;
-      return singleton6;
-    }, 2e3, true);
-  });
-}
-__name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
-
-// src/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx2, timeBudget as timeBudget4 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex8 } from "async-mutex";
-
-// src/archivists/StakeIntentState/local.ts
-import { assertEx } from "@xylabs/sdk-js";
-import { Mutex as Mutex7 } from "async-mutex";
-var mutex7 = new Mutex7();
-var singleton7;
-async function initLocalStakeIntentStateArchivist({ 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 assertEx(singleton7, () => new Error("Failed to initialize stake intent state archivist"));
-  });
-}
-__name(initLocalStakeIntentStateArchivist, "initLocalStakeIntentStateArchivist");
-
-// src/archivists/StakeIntentState/archivist.ts
-var mutex8 = new Mutex8();
-var singleton8;
-async function initStakeIntentStateArchivist(context) {
-  return await mutex8.runExclusive(async () => {
-    if (singleton8) return singleton8;
-    return await timeBudget4("initStakeIntentStateArchivist", context.logger, async () => {
-      const local = await startupSpanAsync4("StakeIntentStateArchivist:initLocal", () => initLocalStakeIntentStateArchivist(context));
-      singleton8 = local;
-      return assertEx2(singleton8, () => "StakeIntentStateArchivist is undefined");
-    }, 2e3, true);
-  });
-}
-__name(initStakeIntentStateArchivist, "initStakeIntentStateArchivist");
-
-// src/buildTelemetryConfig.ts
+// src/shared/buildTelemetryConfig.ts
 function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetricsScrapePort = 9464) {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = defaultMetricsScrapePort } = config.telemetry?.metrics?.scrape ?? {};
@@ -255,8 +84,8 @@ function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetric
 }
 __name(buildTelemetryConfig, "buildTelemetryConfig");
 
-// src/config/actors/Api.ts
-import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/zod";
+// src/shared/config/actors/Api.ts
+import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/sdk-js";
 import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
 import { globalRegistry, z } from "zod";
 var ApiConfigZod = HostActorConfigZod.extend(z.object({
@@ -280,18 +109,18 @@ var isApiConfigContext = zodIsFactory(ApiConfigContext);
 var asApiConfigContext = zodAsFactory(ApiConfigContext, "asApiConfigContext");
 var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
 
-// src/config/actors/Bridge.ts
-import { AddressZod, HexZod, toAddress, toHex } from "@xylabs/sdk-js";
-import { zodAsFactory as zodAsFactory2, zodIsFactory as zodIsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/zod";
+// src/shared/config/actors/Bridge.ts
+import { AddressZod, HexZod, toAddress, toHex, zodAsFactory as zodAsFactory2, zodIsFactory as zodIsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/sdk-js";
 import { AttoXL1ConvertFactor, BaseConfigContextZod as BaseConfigContextZod2, HostActorConfigZod as HostActorConfigZod2, XL1 } from "@xyo-network/xl1-sdk";
 import { globalRegistry as globalRegistry2, z as z2 } from "zod";
-var DEFAULT_FIXED_FEE = toHex(XL1(1n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
 var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
 var DEFAULT_HARDHAT_CHAIN_ID = toHex("7A69");
 var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
 var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f64180aa3");
-var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(100000n) * AttoXL1ConvertFactor.xl1);
-var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(10n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(100000000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
 var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
 var BridgeConfigZod = HostActorConfigZod2.extend({
   escrowAddress: AddressZod.optional().register(globalRegistry2, {
@@ -310,8 +139,8 @@ var BridgeConfigZod = HostActorConfigZod2.extend({
     title: "bridge.feeFixed",
     type: "bigint"
   }),
-  feeRateBasisPoints: BasisPointsZod.default(500).register(globalRegistry2, {
-    default: 500,
+  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+    default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
     description: "Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers",
     title: "bridge.feeRateBasisPoints",
     type: "number"
@@ -396,8 +225,8 @@ var isBridgeConfigContext = zodIsFactory2(BridgeConfigContext);
 var asBridgeConfigContext = zodAsFactory2(BridgeConfigContext, "asBridgeConfigContext");
 var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigContext");
 
-// src/config/actors/Mempool.ts
-import { zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/zod";
+// src/shared/config/actors/Mempool.ts
+import { zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod3, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
 import { globalRegistry as globalRegistry3, z as z3 } from "zod";
 var MempoolConfigZod = HostActorConfigZod3.extend({
@@ -442,9 +271,8 @@ var isMempoolConfigContext = zodIsFactory3(MempoolConfigContext);
 var asMempoolConfigContext = zodAsFactory3(MempoolConfigContext, "asMempoolConfigContext");
 var toMempoolConfigContext = zodToFactory3(MempoolConfigContext, "toMempoolConfigContext");
 
-// src/config/actors/Producer.ts
-import { AddressZod as AddressZod2, asAddress } from "@xylabs/sdk-js";
-import { zodAsFactory as zodAsFactory4, zodIsFactory as zodIsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/zod";
+// src/shared/config/actors/Producer.ts
+import { AddressZod as AddressZod2, asAddress, zodAsFactory as zodAsFactory4, zodIsFactory as zodIsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/sdk-js";
 import { ActorConfigZod, BaseConfigContextZod as BaseConfigContextZod4 } from "@xyo-network/xl1-sdk";
 import { globalRegistry as globalRegistry4, z as z4 } from "zod";
 var ProducerConfigZod = ActorConfigZod.extend(z4.object({
@@ -491,8 +319,8 @@ var isProducerConfigContext = zodIsFactory4(ProducerConfigContext);
 var asProducerConfigContext = zodAsFactory4(ProducerConfigContext, "asProducerConfigContext");
 var toProducerConfigContext = zodToFactory4(ProducerConfigContext, "toProducerConfigContext");
 
-// src/config/actors/RewardRedemption.ts
-import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/zod";
+// src/shared/config/actors/RewardRedemption.ts
+import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod5, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
 var RewardRedemptionConfigZod = HostActorConfigZod4.extend({});
 var isRewardRedemptionConfig = zodIsFactory5(RewardRedemptionConfigZod);
@@ -505,109 +333,47 @@ var isRewardRedemptionConfigContext = zodIsFactory5(RewardRedemptionConfigContex
 var asRewardRedemptionConfigContext = zodAsFactory5(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
 var toRewardRedemptionConfigContext = zodToFactory5(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
 
-// src/config/locators/actors/apiLocatorFromConfig.ts
-import { ProviderFactoryLocator, SimpleXyoConnectionRunner, SimpleXyoGateway, SimpleXyoRunner } from "@xyo-network/xl1-sdk";
-function apiLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([
-    SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
-    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
-    SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {})
-  ]);
-  locator.freeze();
-  return locator;
-}
-__name(apiLocatorFromConfig, "apiLocatorFromConfig");
-
-// src/config/locators/actors/bridgeLocatorFromConfig.ts
-import { isDefined, isString } from "@xylabs/sdk-js";
-import { HDWallet } from "@xyo-network/wallet";
-import { AccountBalanceViewerRpcSchemas, ADDRESS_INDEX, BlockViewerRpcSchemas, FinalizationViewerRpcSchemas, generateXyoBaseWalletFromPhrase, HttpRpcTransport, JsonRpcAccountBalanceViewer, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcXyoRunner, JsonRpcXyoViewer, MempoolRunnerRpcSchemas, MempoolViewerRpcSchemas, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2, SimpleXyoGatewayRunner, SimpleXyoRunner as SimpleXyoRunner2, SimpleXyoSigner, XyoRunnerRpcSchemas, XyoViewerRpcSchemas } from "@xyo-network/xl1-sdk";
-async function bridgeLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator2({
-    ...context,
-    locator: parent
-  });
-  const { config } = context;
-  const { mnemonic } = config;
-  const walletPhrase = isDefined(mnemonic) ? mnemonic : HDWallet.generateMnemonic();
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const signerAccount = await wallet.derivePath(ADDRESS_INDEX.XYO);
-  const remoteUrl = config.remote.rpc?.url;
-  if (isString(remoteUrl)) {
-    const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport(remoteUrl, schemas), "transportFactory");
-    locator.registerMany([
-      JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {
-        transport: await transportFactory(MempoolViewerRpcSchemas)
-      }),
-      JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {
-        transport: await transportFactory(MempoolRunnerRpcSchemas)
-      }),
-      JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {
-        transport: await transportFactory(AccountBalanceViewerRpcSchemas)
-      }),
-      JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {
-        transport: await transportFactory(FinalizationViewerRpcSchemas)
-      }),
-      JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {
-        transport: await transportFactory(BlockViewerRpcSchemas)
-      }),
-      JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {
-        transport: await transportFactory(XyoRunnerRpcSchemas)
-      }),
-      JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {
-        transport: await transportFactory(XyoViewerRpcSchemas)
-      })
-    ]);
-  }
+// src/shared/config/locators/commonLocatorFromConfig.ts
+import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
+import { ProviderFactoryLocator, SimpleBlockRewardViewer, SimpleBlockValidationViewer, SimpleNetworkStakeViewer, SimpleStepRewardsByPositionViewer, SimpleStepRewardsByStakerViewer, SimpleStepRewardsByStepViewer, SimpleStepRewardsTotalViewer, SimpleStepRewardsViewer, SimpleStepViewer, SimpleTimeSyncViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer } from "@xyo-network/xl1-sdk";
+function commonLocatorFromConfig(context, validateDepsOnRegister = false) {
+  let locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister);
   locator.registerMany([
-    SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
-      account: signerAccount
+    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
+    SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {}),
+    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
+    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
+    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
+    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
+    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
+    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {}),
+    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
+      maxWindowSize: 1e4,
+      syncInterval: 1e4
     }),
-    SimpleXyoRunner2.factory(SimpleXyoRunner2.dependencies, {}),
-    SimpleXyoConnectionRunner2.factory(SimpleXyoConnectionRunner2.dependencies, {}),
-    SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
-  ]);
-  locator.freeze();
-  return locator;
-}
-__name(bridgeLocatorFromConfig, "bridgeLocatorFromConfig");
-
-// src/config/locators/actors/mempoolLocatorFromConfig.ts
-import { ProviderFactoryLocator as ProviderFactoryLocator3, SimpleBlockValidationViewer } from "@xyo-network/xl1-sdk";
-function mempoolLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator3({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([
-    SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {})
+    SimpleBlockRewardViewer.factory(SimpleBlockRewardViewer.dependencies, {}),
+    SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+      state: validateHydratedBlockState,
+      protocol: validateHydratedBlock
+    }),
+    SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {})
   ]);
-  locator.freeze();
   return locator;
 }
-__name(mempoolLocatorFromConfig, "mempoolLocatorFromConfig");
-
-// src/config/locators/actors/producerLocatorFromConfig.ts
-import { asAddress as asAddress2, isString as isString3 } from "@xylabs/sdk-js";
-import { SimpleBlockRunner } from "@xyo-network/chain-services";
-import { AccountBalanceViewerRpcSchemas as AccountBalanceViewerRpcSchemas2, BlockViewerRpcSchemas as BlockViewerRpcSchemas2, FinalizationViewerRpcSchemas as FinalizationViewerRpcSchemas2, HttpRpcTransport as HttpRpcTransport2, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2, JsonRpcBlockViewer as JsonRpcBlockViewer2, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer2, JsonRpcMempoolRunner as JsonRpcMempoolRunner2, JsonRpcMempoolViewer as JsonRpcMempoolViewer2, MempoolRunnerRpcSchemas as MempoolRunnerRpcSchemas2, MempoolViewerRpcSchemas as MempoolViewerRpcSchemas2, ProviderFactoryLocator as ProviderFactoryLocator4, SimpleBlockRewardViewer } from "@xyo-network/xl1-sdk";
+__name(commonLocatorFromConfig, "commonLocatorFromConfig");
 
-// src/init/initActorAccount.ts
-import { isDefined as isDefined2, isUndefined } from "@xylabs/sdk-js";
-import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
-import { ADDRESS_INDEX as ADDRESS_INDEX2, generateXyoBaseWalletFromPhrase as generateXyoBaseWalletFromPhrase2 } from "@xyo-network/xl1-sdk";
+// src/shared/init/initActorAccount.ts
+import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { HDWallet } from "@xyo-network/sdk-js";
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
 var actorAccountSingletons = {};
 async function initActorAccount({ config, logger }) {
   const actorName = config.name;
-  if (isDefined2(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
+  if (isDefined(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
   let walletPhrase = config.mnemonic;
   if (isUndefined(walletPhrase)) {
     logger?.warn(`[${actorName}}] No wallet mnemonic specified!`);
-    const randomMnemonic = HDWallet2.generateMnemonic();
+    const randomMnemonic = HDWallet.generateMnemonic();
     logger?.warn(`[${actorName}}] Using randomly generated mnemonic:
     
 ${randomMnemonic}
@@ -615,88 +381,52 @@ ${randomMnemonic}
     `);
     walletPhrase = randomMnemonic;
   }
-  const wallet = await generateXyoBaseWalletFromPhrase2(walletPhrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX2.XYO);
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
   actorAccountSingletons[actorName] = account;
   return actorAccountSingletons[actorName];
 }
 __name(initActorAccount, "initActorAccount");
 
-// src/init/initActorSeedPhrase.ts
-import { assertEx as assertEx3, isString as isString2 } from "@xylabs/sdk-js";
-import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
+// src/shared/init/initActorSeedPhrase.ts
+import { assertEx, isString } from "@xylabs/sdk-js";
+import { HDWallet as HDWallet2 } from "@xyo-network/sdk-js";
 async function initActorSeedPhrase(context, bios) {
   const { logger, config } = context;
   const walletKind = config.name;
   const storedSeedPhrase = await bios.seedPhraseStore.get(walletKind);
   logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`);
   const { mnemonic } = config;
-  if (isString2(storedSeedPhrase) && isString2(mnemonic)) {
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
     logger?.warn("[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.");
     await bios.seedPhraseStore.set(walletKind, mnemonic);
   } else {
     let seedPhrase;
-    if (isString2(mnemonic)) {
+    if (isString(mnemonic)) {
       seedPhrase = mnemonic;
     } else {
-      seedPhrase = HDWallet3.generateMnemonic();
+      seedPhrase = HDWallet2.generateMnemonic();
       logger?.log("[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
       logger?.log(`[API] Mnemonic: ${seedPhrase}`);
     }
     await bios.seedPhraseStore.set(walletKind, seedPhrase);
   }
-  return assertEx3(await bios.seedPhraseStore.get(walletKind), () => "Unable to acquire mnemonic from bios");
+  return assertEx(await bios.seedPhraseStore.get(walletKind), () => "Unable to acquire mnemonic from bios");
 }
 __name(initActorSeedPhrase, "initActorSeedPhrase");
 
-// src/init/initBalanceSummaryMap.ts
-import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
-import { MongoMap } from "@xyo-network/chain-protocol";
-import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
-async function initBalanceSummaryMap({ logger, config }) {
-  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
-      }
-    });
-    assertEx4(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 assertEx5 } from "@xylabs/sdk-js";
+// src/shared/init/initBridgedModule.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance, asAttachableModuleInstance } from "@xyo-network/sdk-js";
-import { Mutex as Mutex9 } from "async-mutex";
-var initMutex = new Mutex9();
+import { Mutex } from "async-mutex";
+var initMutex = new Mutex();
 var bridgedModuleDictionary = {};
 async function initBridgedModule({ bridge, moduleName }) {
   return await initMutex.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
-    const mod = assertEx5(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx5(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    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 = {};
@@ -708,25 +438,25 @@ async function initBridgedModule({ bridge, moduleName }) {
 }
 __name(initBridgedModule, "initBridgedModule");
 async function initBridgedArchivistModule({ bridge, moduleName }) {
-  return assertEx5(asAttachableArchivistInstance(await initBridgedModule({
+  return assertEx2(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
 }
 __name(initBridgedArchivistModule, "initBridgedArchivistModule");
 
-// src/init/initEvmProvidersIfAvailable.ts
-import { asEthAddress, assertEx as assertEx10 } from "@xylabs/sdk-js";
+// src/shared/init/initEvmProvidersIfAvailable.ts
+import { asEthAddress, assertEx as assertEx7 } 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";
+import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer as SimpleTimeSyncViewer2, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
 
-// src/evm/initChainId.ts
-import { assertEx as assertEx6, hexFrom, isDefined as isDefined3, isHex } from "@xylabs/sdk-js";
+// src/shared/evm/initChainId.ts
+import { assertEx as assertEx3, hexFrom, isDefined as isDefined2, isHex } from "@xylabs/sdk-js";
 var canUseChainId = /* @__PURE__ */ __name(({ config }) => {
-  return isDefined3(config.evm.chainId);
+  return isDefined2(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
   })) {
@@ -739,11 +469,11 @@ var getChainId = /* @__PURE__ */ __name(({ config }) => {
   }
 }, "getChainId");
 
-// src/evm/initEvmProvider.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+// src/shared/evm/initEvmProvider.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 
-// src/evm/initInfuraProvider.ts
-import { assertEx as assertEx7, isDefined as isDefined4 } from "@xylabs/sdk-js";
+// src/shared/evm/initInfuraProvider.ts
+import { assertEx as assertEx4, isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 var instance;
 var initInfuraProvider = /* @__PURE__ */ __name((context) => {
@@ -754,12 +484,12 @@ var initInfuraProvider = /* @__PURE__ */ __name((context) => {
 }, "initInfuraProvider");
 var canUseInfuraProvider = /* @__PURE__ */ __name((context) => {
   const { config } = context;
-  return canUseChainId(context) && isDefined4(config.evm?.infura?.projectId) && isDefined4(config.evm?.infura?.projectSecret);
+  return canUseChainId(context) && isDefined3(config.evm?.infura?.projectId) && isDefined3(config.evm?.infura?.projectSecret);
 }, "canUseInfuraProvider");
 var getInfuraProviderConfig = /* @__PURE__ */ __name((context) => {
   const { config } = context;
-  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(context),
     projectId,
@@ -767,8 +497,8 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((context) => {
   ];
 }, "getInfuraProviderConfig");
 
-// src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx8, isDefined as isDefined5 } from "@xylabs/sdk-js";
+// src/shared/evm/initJsonRpcProvider.ts
+import { assertEx as assertEx5, isDefined as isDefined4 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((context) => {
   const providerConfig = getJsonRpcProviderConfig(context);
@@ -776,18 +506,18 @@ var initJsonRpcProvider = /* @__PURE__ */ __name((context) => {
 }, "initJsonRpcProvider");
 var canUseJsonRpcProvider = /* @__PURE__ */ __name((context) => {
   const { config } = context;
-  return canUseChainId(context) && isDefined5(config.evm.jsonRpc?.url);
+  return canUseChainId(context) && isDefined4(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((context) => {
   const { config } = context;
-  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(context)
   ];
 }, "getJsonRpcProviderConfig");
 
-// src/evm/initEvmProvider.ts
+// src/shared/evm/initEvmProvider.ts
 var provider;
 var initEvmProvider = /* @__PURE__ */ __name(async (context) => {
   if (provider) return provider;
@@ -796,18 +526,18 @@ var initEvmProvider = /* @__PURE__ */ __name(async (context) => {
   } else if (canUseJsonRpcProvider(context)) {
     provider = initJsonRpcProvider(context);
   }
-  return assertEx9(await provider, () => "No provider available");
+  return assertEx6(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name((context) => {
   return canUseInfuraProvider(context) || canUseJsonRpcProvider(context);
 }, "canUseEvmProvider");
 
-// src/init/initEvmProvidersIfAvailable.ts
-async function initEvmProvidersIfAvailable(locator, defaultChainId) {
+// src/shared/init/initEvmProvidersIfAvailable.ts
+async function initEvmProvidersIfAvailable(locator) {
   const context = locator.context;
-  const { logger, config } = context;
+  const { logger } = context;
   if (canUseEvmProvider(context)) {
-    const chainId = assertEx10(context.config.chain.id, () => "Missing config.chain.id (required for EVM providers)");
+    const chainId = assertEx7(context.config.chain.id, () => "Missing config.chain.id (required for EVM providers)");
     const provider2 = await initEvmProvider(context);
     const address = asEthAddress(chainId, true);
     locator.register(EvmStakeEventsViewer.factory(EvmStakeEventsViewer.dependencies, {
@@ -826,13 +556,12 @@ async function initEvmProvidersIfAvailable(locator, defaultChainId) {
       address,
       provider: provider2
     }));
-    locator.register(SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {
+    locator.register(SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {
       ethProvider: provider2
     }));
   } else {
     logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
     const positions = [];
-    const chainId = assertEx10(config.chain.id ?? defaultChainId, () => "Missing config.chain.id or defaultChainId (required for non-EVM providers)");
     locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {
       positions
     }));
@@ -841,330 +570,17 @@ async function initEvmProvidersIfAvailable(locator, defaultChainId) {
     }));
     locator.register(SimpleStakeTotalsViewer.factory(SimpleStakeTotalsViewer.dependencies, {}));
     locator.register(SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
-      chainId,
       minWithdrawalBlocks: 10,
       stakingTokenAddress: XYO_ZERO_ADDRESS,
       rewardsContract: XYO_ZERO_ADDRESS
     }));
-    locator.register(SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {}));
+    locator.register(SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {}));
   }
   return locator;
 }
 __name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
-// src/init/initFinalizationArchivistIfNeeded.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
-import { createBootstrapHead } from "@xyo-network/chain-sdk";
-import { Account } from "@xyo-network/sdk-js";
-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 ?? assertEx11(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
-  const chainId = assertEx11(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) {
-  const payloadSdkConfig = {
-    ...config.storage.mongo,
-    collection: "chain_validated"
-  };
-  return await MongoDBArchivistV2.create({
-    payloadSdkConfig
-  });
-}
-__name(initMongoFinalizedArchivist, "initMongoFinalizedArchivist");
-async function initFinalizedArchivist(config) {
-  const finalizedArchivist = await initMongoFinalizedArchivist(config);
-  return finalizedArchivist;
-}
-__name(initFinalizedArchivist, "initFinalizedArchivist");
-
-// src/init/initServerNode.ts
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
-import { asArchivistInstance } from "@xyo-network/sdk-js";
-
-// src/manifest/getLocator.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
-import { MemoryArchivist as MemoryArchivist2 } from "@xyo-network/archivist-memory";
-import { MongoDBArchivistV2 as MongoDBArchivistV22, MongoDBArchivistV2Deletable } from "@xyo-network/archivist-mongodb";
-import { ViewArchivist } from "@xyo-network/archivist-view";
-import { initTelemetry } from "@xyo-network/chain-telemetry";
-import { AbstractModule, LoggerModuleStatusReporter } from "@xyo-network/module-abstract";
-import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
-import { MemorySentinel } from "@xyo-network/sentinel-memory";
-import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-sdk";
-var getLocator = /* @__PURE__ */ __name(async ({ logger, config }) => {
-  const { otlpEndpoint } = config.telemetry?.otel ?? {};
-  const { path: endpoint = "/metrics", port = 9465 } = config.telemetry?.metrics?.scrape ?? {};
-  const { traceProvider, meterProvider } = await initTelemetry({
-    attributes: {
-      serviceName: "xl1-api",
-      serviceVersion: "1.0.0"
-    },
-    otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
-  });
-  if (isDefined6(logger)) AbstractModule.defaultLogger = logger;
-  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
-  const locator = new ModuleFactoryLocator();
-  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
-    };
-    const params = {
-      meterProvider,
-      payloadSdkConfig,
-      statusReporter,
-      traceProvider
-    };
-    locator.register(MongoDBArchivistV22.factory(params), void 0, true);
-    locator.register(MongoDBArchivistV2Deletable.factory(params), {
-      "network.xyo.storage.capabilities.delete": "enabled"
-    }, false);
-  }
-  locator.register(MemoryArchivist2.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
-  locator.register(MemorySentinel.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
-  locator.register(ViewArchivist.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
-  return locator;
-}, "getLocator");
-
-// src/manifest/loadNode.ts
-import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
-
-// src/manifest/node.json
-var node_default = {
-  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  nodes: [
-    {
-      config: {
-        accountPath: "44'/60'/1",
-        name: "XYOChain",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [],
-        public: []
-      }
-    }
-  ],
-  schema: "network.xyo.manifest"
-};
-
-// src/manifest/nodeManifest.ts
-var NodeManifest = node_default;
-
-// src/manifest/private/index.ts
-var PrivateChildManifests = [];
-
-// 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: [
-    {
-      config: {
-        accountPath: "1",
-        name: "Chain",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [
-          {
-            config: {
-              accountPath: "1/1'/1'",
-              name: "Validated",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              payloadSdkConfig: {
-                collection: "chain_validated"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          }
-        ],
-        public: [
-          {
-            config: {
-              accountPath: "1/1/1",
-              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"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  schema: "network.xyo.manifest"
-};
-
-// 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: [
-    {
-      config: {
-        accountPath: "2",
-        name: "Pending",
-        schema: "network.xyo.node.config"
-      },
-      modules: {
-        private: [],
-        public: [
-          {
-            config: {
-              accountPath: "2/1/1",
-              name: "Transactions",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              labels: {
-                "network.xyo.storage.capabilities.delete": "enabled",
-                "network.xyo.storage.class": "mongodb"
-              },
-              payloadSdkConfig: {
-                collection: "pending_transaction_bundles"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          },
-          {
-            config: {
-              accountPath: "2/1/2",
-              name: "Blocks",
-              getCache: {
-                enabled: true,
-                maxEntries: 5e3
-              },
-              labels: {
-                "network.xyo.storage.capabilities.delete": "enabled",
-                "network.xyo.storage.class": "mongodb"
-              },
-              payloadSdkConfig: {
-                collection: "pending_block_bundles"
-              },
-              schema: "network.xyo.archivist.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  schema: "network.xyo.manifest"
-};
-
-// src/manifest/public/index.ts
-var ChainNodeManifest = Chain_default;
-var PendingNodeManifest = Pending_default;
-var PublicChildManifests = [
-  ...ChainNodeManifest.nodes,
-  ...PendingNodeManifest.nodes
-];
-
-// src/manifest/loadNode.ts
-var loadNode = /* @__PURE__ */ __name(async (context, wallet) => {
-  const locator = await getLocator(context);
-  const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests);
-  const [node, ...childNodes] = await wrapper.loadNodes();
-  if (childNodes?.length > 0) {
-    await Promise.all(childNodes.map((childNode) => node.register(childNode)));
-    await Promise.all(childNodes.map((childNode) => node.attach(childNode.address, true)));
-  }
-  return node;
-}, "loadNode");
-
-// src/init/initServerNode.ts
-async function writableChainArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("Chain:Validated"), {
-    required: true
-  });
-}
-__name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
-async function readonlyChainArchivistFromNode(node) {
-  return assertEx12(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
-  });
-}
-__name(pendingTransactionsArchivistFromNode, "pendingTransactionsArchivistFromNode");
-async function pendingBlocksArchivistFromNode(node) {
-  return asArchivistInstance(await node.resolve("XYOChain:Pending:Blocks"), {
-    required: true
-  });
-}
-__name(pendingBlocksArchivistFromNode, "pendingBlocksArchivistFromNode");
-async function initServerNode(context, wallet, providedNode) {
-  const node = providedNode ?? await loadNode(context, wallet);
-  assertEx12(await node.start(), () => "Failed to start node");
-  const writableChainArchivist = await writableChainArchivistFromNode(node);
-  const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
-  const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
-  const pendingBlocksArchivist = await pendingBlocksArchivistFromNode(node);
-  return {
-    node,
-    writableChainArchivist,
-    readonlyChainArchivist,
-    pendingTransactionsArchivist,
-    pendingBlocksArchivist
-  };
-}
-__name(initServerNode, "initServerNode");
-
-// src/init/initStatusReporter.ts
+// src/shared/init/initStatusReporter.ts
 import { RuntimeStatusMonitor } from "@xyo-network/xl1-sdk";
 function initStatusReporter({ logger }) {
   const statusReporter = new RuntimeStatusMonitor(logger);
@@ -1183,133 +599,23 @@ function initStatusReporter({ logger }) {
 }
 __name(initStatusReporter, "initStatusReporter");
 
-// src/init/initTransferSummaryMap.ts
-import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-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({ logger, config }) {
-  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
-    };
-    const sdkTransferSummaryMap = new BaseMongoSdk2({
-      ...payloadSdkConfig,
-      collection: "transfer_summary_map"
-    });
-    const result = await MongoMap2.create({
-      sdk: sdkTransferSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
-    });
-    assertEx13(await result.start(), () => "Failed to start transfer summary map");
-    return result;
-  } else {
-    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
-    return new MemoryMap2();
-  }
-}
-__name(initTransferSummaryMap, "initTransferSummaryMap");
-
-// src/init/initWallet.ts
-import { isDefined as isDefined7 } from "@xylabs/sdk-js";
+// src/shared/init/initWallet.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
+import { HDWallet as HDWallet3 } from "@xyo-network/sdk-js";
 async function initActorWallet(context, mnemonic) {
   const bios = await boot();
-  const seedPhrase = isDefined7(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
-  return await HDWallet4.fromPhrase(seedPhrase);
+  const seedPhrase = isDefined5(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
+  return await HDWallet3.fromPhrase(seedPhrase);
 }
 __name(initActorWallet, "initActorWallet");
 
-// src/config/locators/actors/producerLocatorFromConfig.ts
-async function producerLocatorFromConfig(context, parent) {
-  const { logger, config } = context;
-  const account = await initActorAccount(context);
-  const locator = new ProviderFactoryLocator4({
-    ...context,
-    locator: parent
-  });
-  const rewardAddress = asAddress2(config.rewardAddress ?? account.address, true);
-  logger?.info(`Using reward address ${rewardAddress}`);
-  if (rewardAddress === account.address) {
-    logger?.warn(`Using producer account address as reward address: ${account.address}`);
-  }
-  const remoteUrl = config.remote.rpc?.url;
-  if (isString3(remoteUrl)) {
-    const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport2(remoteUrl, schemas), "transportFactory");
-    locator.registerMany([
-      JsonRpcMempoolViewer2.factory(JsonRpcMempoolViewer2.dependencies, {
-        transport: await transportFactory(MempoolViewerRpcSchemas2)
-      }),
-      JsonRpcMempoolRunner2.factory(JsonRpcMempoolRunner2.dependencies, {
-        transport: await transportFactory(MempoolRunnerRpcSchemas2)
-      }),
-      JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {
-        transport: await transportFactory(AccountBalanceViewerRpcSchemas2)
-      }),
-      JsonRpcFinalizationViewer2.factory(JsonRpcFinalizationViewer2.dependencies, {
-        transport: await transportFactory(FinalizationViewerRpcSchemas2)
-      }),
-      JsonRpcBlockViewer2.factory(JsonRpcBlockViewer2.dependencies, {
-        transport: await transportFactory(BlockViewerRpcSchemas2)
-      })
-    ]);
-  }
-  locator.registerMany([
-    SimpleBlockRewardViewer.factory(SimpleBlockRewardViewer.dependencies, {}),
-    SimpleBlockRunner.factory(SimpleBlockRunner.dependencies, {
-      account,
-      rewardAddress
-    })
-  ]);
-  locator.freeze();
-  return locator;
-}
-__name(producerLocatorFromConfig, "producerLocatorFromConfig");
-
-// src/config/locators/actors/rewardRedemptionLocatorFromConfig.ts
-import { ProviderFactoryLocator as ProviderFactoryLocator5, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2 } from "@xyo-network/xl1-sdk";
-function rewardRedemptionLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator5({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([
-    SimpleXyoGatewayRunner2.factory(SimpleXyoGatewayRunner2.dependencies, {})
-  ]);
-  locator.freeze();
-  return locator;
-}
-__name(rewardRedemptionLocatorFromConfig, "rewardRedemptionLocatorFromConfig");
-
-// src/config/locators/actors/validatorLocatorFromConfig.ts
-import { ProviderFactoryLocator as ProviderFactoryLocator6 } from "@xyo-network/xl1-sdk";
-function validatorLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator6({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([]);
-  locator.freeze();
-  return locator;
-}
-__name(validatorLocatorFromConfig, "validatorLocatorFromConfig");
-
-// src/config/locators/telemetryContextFromConfig.ts
-import { initTelemetry as initTelemetry2 } from "@xyo-network/chain-telemetry";
+// src/shared/config/locators/telemetryContextFromConfig.ts
+import { initTelemetry } from "@xyo-network/chain-telemetry";
 async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
   const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
-  return await initTelemetry2({
+  return await initTelemetry({
     attributes: {
       serviceName,
       serviceVersion
@@ -1323,7 +629,7 @@ async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
 }
 __name(telemetryContextFromConfig, "telemetryContextFromConfig");
 
-// src/config/locators/contextFromConfigWithoutLocator.ts
+// src/shared/config/locators/contextFromConfigWithoutLocator.ts
 async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion) {
   const singletons = {};
   const caches = {};
@@ -1342,220 +648,41 @@ async function contextFromConfigWithoutLocator(config, logger, serviceName, serv
 }
 __name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
 
-// src/config/locators/localLocatorFromConfig.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
-import { ProviderFactoryLocator as ProviderFactoryLocator7, SimpleAccountBalanceViewer, SimpleBlockViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer } from "@xyo-network/xl1-sdk";
-async function localLocatorFromConfig(context, parent) {
-  const balancesSummaryMap = assertEx14(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
-  const transfersSummaryMap = assertEx14(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
-  const wallet = await initActorWallet(context);
-  const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist } = await initServerNode(context, wallet);
-  const [_head, chainId] = await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet);
-  const locator = new ProviderFactoryLocator7({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([
-    SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
-      pendingTransactionsArchivist,
-      pendingBlocksArchivist
-    }),
-    SimpleMempoolRunner.factory(SimpleMempoolRunner.dependencies, {
-      pendingTransactionsArchivist,
-      pendingBlocksArchivist
-    }),
-    SimpleAccountBalanceViewer.factory(SimpleAccountBalanceViewer.dependencies, {
-      balancesSummaryMap,
-      transfersSummaryMap
-    }),
-    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
-      maxWindowSize: 1e4,
-      syncInterval: 1e4
-    }),
-    SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
-    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
-      finalizedArchivist: readonlyChainArchivist
-    }),
-    SimpleFinalizationRunner.factory(SimpleFinalizationRunner.dependencies, {
-      finalizedArchivist: writableChainArchivist
-    })
-  ]);
-  return [
-    locator,
-    chainId
-  ];
-}
-__name(localLocatorFromConfig, "localLocatorFromConfig");
-
-// src/config/locators/locatorsFromConfig.ts
-import { deepMerge } from "@xylabs/sdk-js";
-import { ActorConfigZod as ActorConfigZod2 } from "@xyo-network/xl1-sdk";
-
-// src/config/locators/rootLocatorFromConfig.ts
-import { isString as isString4 } from "@xylabs/sdk-js";
-import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
-import { ProviderFactoryLocator as ProviderFactoryLocator9, SimpleBlockValidationViewer as SimpleBlockValidationViewer2, SimpleNetworkStakeViewer, SimpleStepRewardsByPositionViewer, SimpleStepRewardsByStakerViewer, SimpleStepRewardsByStepViewer, SimpleStepRewardsTotalViewer, SimpleStepRewardsViewer, SimpleStepViewer, SimpleTimeSyncViewer as SimpleTimeSyncViewer2, SimpleTransactionViewer } from "@xyo-network/xl1-sdk";
-
-// src/config/locators/remoteLocatorFromConfig.ts
-import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3, JsonRpcBlockViewer as JsonRpcBlockViewer3, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer3, JsonRpcMempoolRunner as JsonRpcMempoolRunner3, JsonRpcMempoolViewer as JsonRpcMempoolViewer3, JsonRpcXyoViewer as JsonRpcXyoViewer2, ProviderFactoryLocator as ProviderFactoryLocator8, SimpleWindowedBlockViewer as SimpleWindowedBlockViewer2 } from "@xyo-network/xl1-sdk";
-function remoteLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator8({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([
-    JsonRpcMempoolViewer3.factory(JsonRpcMempoolViewer3.dependencies, {}),
-    JsonRpcMempoolRunner3.factory(JsonRpcMempoolRunner3.dependencies, {}),
-    JsonRpcAccountBalanceViewer3.factory(JsonRpcAccountBalanceViewer3.dependencies, {}),
-    JsonRpcFinalizationViewer3.factory(JsonRpcFinalizationViewer3.dependencies, {}),
-    JsonRpcBlockViewer3.factory(JsonRpcBlockViewer3.dependencies, {}),
-    SimpleWindowedBlockViewer2.factory(SimpleWindowedBlockViewer2.dependencies, {
-      maxWindowSize: 1e4,
-      syncInterval: 1e4
-    }),
-    JsonRpcXyoViewer2.factory(JsonRpcXyoViewer2.dependencies, {})
-  ]);
-  locator.freeze();
-  return [
-    locator,
-    null
-  ];
-}
-__name(remoteLocatorFromConfig, "remoteLocatorFromConfig");
-
-// src/config/locators/rootLocatorFromConfig.ts
-async function rootLocatorFromConfig(context) {
-  const { config } = context;
-  let locator = new ProviderFactoryLocator9(context);
+// src/shared/config/locators/remoteLocatorFromConfig.ts
+import { JsonRpcAccountBalanceViewer, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcNetworkStakeViewer, JsonRpcStakeViewer, JsonRpcTransactionViewer, JsonRpcXyoViewer, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleStakeEventsViewer as SimpleStakeEventsViewer2 } from "@xyo-network/xl1-sdk";
+function remoteLocatorFromConfig(context, validateDepsOnRegister = false) {
+  const locator = new ProviderFactoryLocator2(context, {}, validateDepsOnRegister);
   locator.registerMany([
-    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
-    SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {}),
-    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
-    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
-    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
-    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
-    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
-    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {}),
-    SimpleBlockValidationViewer2.factory(SimpleBlockValidationViewer2.dependencies, {
-      state: validateHydratedBlockState,
-      protocol: validateHydratedBlock
+    JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {}),
+    JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {}),
+    JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {}),
+    JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {}),
+    JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {}),
+    JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {}),
+    JsonRpcNetworkStakeViewer.factory(JsonRpcNetworkStakeViewer.dependencies, {}),
+    JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {}),
+    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, {
+      positions: []
     }),
-    SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {})
+    JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
   ]);
-  const [newLocator, chainId] = await (isString4(config.remote.rpc?.url) ? remoteLocatorFromConfig(context, locator) : localLocatorFromConfig(context, locator));
-  locator = newLocator;
-  locator = await initEvmProvidersIfAvailable(locator, chainId);
-  locator.freeze();
   return locator;
 }
-__name(rootLocatorFromConfig, "rootLocatorFromConfig");
-
-// src/config/locators/locatorsFromConfig.ts
-async function locatorsFromConfig(context, { actors, ...config }) {
-  const result = {
-    _root: await rootLocatorFromConfig({
-      ...context,
-      config: {
-        ...config,
-        name: "_root"
-      }
-    })
-  };
-  for (const actorConfig of actors) {
-    switch (actorConfig.name) {
-      case "producer": {
-        result[actorConfig.name] = await producerLocatorFromConfig({
-          ...context,
-          config: ProducerConfigZod.parse(deepMerge(config, actorConfig))
-        }, result._root);
-        break;
-      }
-      case "api": {
-        result[actorConfig.name] = await apiLocatorFromConfig({
-          ...context,
-          config: ApiConfigZod.parse(deepMerge(config, actorConfig))
-        }, result._root);
-        break;
-      }
-      case "mempool": {
-        result[actorConfig.name] = await mempoolLocatorFromConfig({
-          ...context,
-          config: MempoolConfigZod.parse(deepMerge(config, actorConfig))
-        }, result._root);
-        break;
-      }
-      case "validator": {
-        result[actorConfig.name] = await validatorLocatorFromConfig({
-          ...context,
-          config: ActorConfigZod2.parse(deepMerge(config, actorConfig))
-        }, result._root);
-        break;
-      }
-      case "bridge": {
-        result[actorConfig.name] = await bridgeLocatorFromConfig({
-          ...context,
-          config: BridgeConfigZod.parse(deepMerge(config, actorConfig))
-        }, result._root);
-        break;
-      }
-      case "rewardRedemption": {
-        result[actorConfig.name] = await rewardRedemptionLocatorFromConfig({
-          ...context,
-          config: RewardRedemptionConfigZod.parse(deepMerge(config, actorConfig))
-        }, result._root);
-        break;
-      }
-    }
-  }
-  return result;
-}
-__name(locatorsFromConfig, "locatorsFromConfig");
+__name(remoteLocatorFromConfig, "remoteLocatorFromConfig");
 
-// src/config/mergeConfig.ts
-import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
+// src/shared/config/mergeConfig.ts
+import { deepMerge } from "@xylabs/sdk-js";
 function mergeConfig({ actors, ...baseConfig }) {
   return {
     ...baseConfig,
     actors: actors.map((actor) => {
-      return deepMerge2(baseConfig, actor);
+      return deepMerge(baseConfig, actor);
     })
   };
 }
 __name(mergeConfig, "mergeConfig");
 
-// src/config/tryParseConfig.ts
-import { isDefined as isDefined8, isNull } from "@xylabs/sdk-js";
-import { ConfigZod } from "@xyo-network/xl1-sdk";
-import { cosmiconfig } from "cosmiconfig";
-var configName = "xyo";
-var configSection = "xl1";
-async function tryParseConfig(searchPlaces) {
-  const explorer = cosmiconfig(configName, {
-    cache: true,
-    // loaders: { '.ts': TypeScriptLoader() },
-    searchPlaces
-  });
-  const result = (await explorer.search())?.config;
-  if (isDefined8(result) && !isNull(result)) {
-    const section = result[configSection];
-    if (isDefined8(section) && typeof section === "object") {
-      return ConfigZod.loose().parse(section);
-    }
-  }
-  return ConfigZod.parse({});
-}
-__name(tryParseConfig, "tryParseConfig");
-
-// src/createDeclarationIntentBlock.ts
+// src/shared/createDeclarationIntentBlock.ts
 import { buildNextBlock } from "@xyo-network/chain-sdk";
 import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
 async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
@@ -1568,65 +695,7 @@ async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, r
 }
 __name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
-// src/health/initHealthEndpoints.ts
-import http from "http";
-import { isDefined as isDefined9 } 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((context, port, statusMonitor) => {
-  const { logger } = context;
-  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");
-function initHealthEndpoints(context, statusMonitor) {
-  const { config } = context;
-  const { healthCheckPort } = config;
-  return isDefined9(healthCheckPort) ? createHealthServer(context, healthCheckPort, statusMonitor) : void 0;
-}
-__name(initHealthEndpoints, "initHealthEndpoints");
-
-// src/host/implementation/DefaultHost.ts
+// src/shared/host/implementation/DefaultHost.ts
 var GenericHost = class {
   static {
     __name(this, "GenericHost");
@@ -1645,7 +714,7 @@ var GenericHost = class {
   }
 };
 
-// src/host/implementation/DefaultServiceProvider.ts
+// src/shared/host/implementation/DefaultServiceProvider.ts
 var DefaultServiceProvider = class {
   static {
     __name(this, "DefaultServiceProvider");
@@ -1659,13 +728,13 @@ var DefaultServiceProvider = class {
   }
 };
 
-// src/host/model/ServiceCollection.ts
+// src/shared/host/model/ServiceCollection.ts
 var ServiceLifetime = {
   Singleton: "Singleton",
   Transient: "Transient"
 };
 
-// src/orchestrator/Orchestrator.ts
+// src/shared/orchestrator/Orchestrator.ts
 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;
@@ -1729,6 +798,96 @@ var Orchestrator = class extends AbstractCreatable {
 Orchestrator = _ts_decorate2([
   creatable2()
 ], Orchestrator);
+
+// src/neutral/config/locators/basicRemoteRunnerLocator.ts
+import { isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { JsonRpcXyoRunner, JsonRpcXyoSigner, ProviderFactoryLocator as ProviderFactoryLocator4, RestDataLakeViewer as RestDataLakeViewer2, SimpleXyoConnectionRunner, SimpleXyoGatewayRunner } from "@xyo-network/xl1-sdk";
+
+// src/neutral/config/locators/basicRemoteViewerLocator.ts
+import { assertEx as assertEx8, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { ActorConfigZod as ActorConfigZod2, BaseConfigZod, BlockViewerMoniker as BlockViewerMoniker2, JsonRpcBlockViewer as JsonRpcBlockViewer2, ProviderFactoryLocator as ProviderFactoryLocator3, RestDataLakeViewer, SimpleTransactionViewer as SimpleTransactionViewer2, SimpleXyoConnectionViewer, SimpleXyoGateway } from "@xyo-network/xl1-sdk";
+async function getChainIdFromRemote(remoteConfig) {
+  const locator = new ProviderFactoryLocator3({
+    config: BaseConfigZod.parse({
+      remote: remoteConfig
+    }),
+    singletons: {},
+    caches: {}
+  });
+  locator.registerMany([
+    JsonRpcBlockViewer2.factory(JsonRpcBlockViewer2.dependencies, {})
+  ]);
+  locator.freeze();
+  const blockViewer = await locator.getInstance(BlockViewerMoniker2);
+  return assertEx8(await blockViewer.chainId(), () => "Chain ID could not be determined from remote config");
+}
+__name(getChainIdFromRemote, "getChainIdFromRemote");
+async function basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint) {
+  const config = ActorConfigZod2.parse({
+    name,
+    remote: remoteConfig,
+    chain: {
+      id: chainId ?? await getChainIdFromRemote(remoteConfig)
+    }
+  });
+  const rootLocator = await commonLocatorFromConfig({
+    config,
+    singletons: {},
+    caches: {}
+  });
+  const remoteLocator = await remoteLocatorFromConfig(rootLocator.context);
+  const locator = new ProviderFactoryLocator3(remoteLocator.context, {});
+  locator.registerMany([
+    SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {}),
+    SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleTransactionViewer2.factory(SimpleTransactionViewer2.dependencies, {})
+  ]);
+  if (isDefined6(dataLakeEndpoint)) {
+    const dataLakeViewerParams = {
+      endpoint: dataLakeEndpoint
+    };
+    locator.register(RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, dataLakeViewerParams));
+  }
+  locator.freeze();
+  return locator;
+}
+__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
+
+// src/neutral/config/locators/basicRemoteRunnerLocator.ts
+async function basicRemoteRunnerLocator(name, remoteConfig, signerTransport, chainId, dataLakeEndpoint) {
+  const remoteViewerLocator = await basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint);
+  const locator = new ProviderFactoryLocator4(remoteViewerLocator.context, {});
+  locator.registerMany([
+    JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, {
+      transport: signerTransport
+    }),
+    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
+    JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {}),
+    SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
+  ]);
+  if (isDefined7(dataLakeEndpoint)) {
+    const dataLakeViewerParams = {
+      endpoint: dataLakeEndpoint
+    };
+    locator.register(RestDataLakeViewer2.factory(RestDataLakeViewer2.dependencies, dataLakeViewerParams));
+  }
+  locator.freeze();
+  return locator;
+}
+__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
+
+// src/neutral/config/locators/rootLocatorFromConfig.ts
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
+  const { config } = context;
+  let locator = await commonLocatorFromConfig(context, validateDepsOnRegister);
+  const newLocator = await (config.remote.rpc ? remoteLocatorFromConfig(context, validateDepsOnRegister) : void 0);
+  locator = assertEx9(newLocator, () => "Root locator could not be created from config. No supported configuration found.");
+  locator = await initEvmProvidersIfAvailable(locator);
+  locator.freeze();
+  return locator;
+}
+__name(rootLocatorFromConfig, "rootLocatorFromConfig");
 export {
   ApiConfigContext,
   ApiConfigZod,
@@ -1740,17 +899,13 @@ export {
   GenericHost,
   MempoolConfigContext,
   MempoolConfigZod,
-  NodeManifest,
   Orchestrator,
-  PrivateChildManifests,
   ProducerConfigContext,
   ProducerConfigZod,
-  PublicChildManifests,
   RewardRedemptionConfigContext,
   RewardRedemptionConfigZod,
   ServiceLifetime,
   ValidatorActor,
-  apiLocatorFromConfig,
   asApiConfig,
   asApiConfigContext,
   asBridgeConfig,
@@ -1761,38 +916,29 @@ export {
   asProducerConfigContext,
   asRewardRedemptionConfig,
   asRewardRedemptionConfigContext,
-  bridgeLocatorFromConfig,
+  basicRemoteRunnerLocator,
+  basicRemoteViewerLocator,
   buildTelemetryConfig,
   canUseChainId,
   canUseEvmProvider,
   canUseInfuraProvider,
   canUseJsonRpcProvider,
+  commonLocatorFromConfig,
   contextFromConfigWithoutLocator,
   createProducerChainStakeIntentBlock,
   getChainId,
   getInfuraProviderConfig,
   getJsonRpcProviderConfig,
-  getLocator,
   initActorAccount,
   initActorSeedPhrase,
   initActorWallet,
-  initBalanceSummaryMap,
   initBridgedArchivistModule,
   initBridgedModule,
-  initChainFinalizedArchivist,
   initEvmProvider,
   initEvmProvidersIfAvailable,
-  initFinalizationArchivistIfNeeded,
-  initFinalizedArchivist,
-  initHealthEndpoints,
   initInfuraProvider,
   initJsonRpcProvider,
-  initPendingBlocksArchivist,
-  initRejectedTransactionsArchivist,
-  initServerNode,
-  initStakeIntentStateArchivist,
   initStatusReporter,
-  initTransferSummaryMap,
   isApiConfig,
   isApiConfigContext,
   isBridgeConfig,
@@ -1803,14 +949,8 @@ export {
   isProducerConfigContext,
   isRewardRedemptionConfig,
   isRewardRedemptionConfigContext,
-  loadNode,
-  localLocatorFromConfig,
-  locatorsFromConfig,
-  mempoolLocatorFromConfig,
   mergeConfig,
-  producerLocatorFromConfig,
   remoteLocatorFromConfig,
-  rewardRedemptionLocatorFromConfig,
   rootLocatorFromConfig,
   telemetryContextFromConfig,
   toApiConfig,
@@ -1822,8 +962,6 @@ export {
   toProducerConfig,
   toProducerConfigContext,
   toRewardRedemptionConfig,
-  toRewardRedemptionConfigContext,
-  tryParseConfig,
-  validatorLocatorFromConfig
+  toRewardRedemptionConfigContext
 };
 //# sourceMappingURL=index.mjs.map