@xyo-network/chain-orchestration 1.20.17 → 1.20.19

package/dist/node/index.mjs

@@ -4,7 +4,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/shared/actor/ValidatorActor.ts
 import { creatable } from "@xylabs/sdk-js";
 import { processPendingBlocks } from "@xyo-network/chain-sdk";
-import { ActorV3, BlockValidationViewerMoniker, BlockViewerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+import { ActorV3, BlockValidationViewerMoniker, BlockViewerMoniker, DeadLetterQueueRunnerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -18,6 +18,7 @@ var ValidatorActor = class extends ActorV3 {
   }
   _blockValidationViewer;
   _blockViewer;
+  _deadLetterQueueRunner;
   _finalizationRunner;
   _lastValidatedBlock;
   _lastValidatedBlockHash;
@@ -37,18 +38,22 @@ var ValidatorActor = class extends ActorV3 {
   get mempoolViewer() {
     return this._mempoolViewer;
   }
+  get minCandidates() {
+    return this.params.config.minCandidates;
+  }
   async createHandler() {
     await super.startHandler();
     this._blockValidationViewer = await this.locator.getInstance(BlockValidationViewerMoniker);
     this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
     this._finalizationRunner = await this.locator.getInstance(FinalizationRunnerMoniker);
     this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker);
+    this._deadLetterQueueRunner = await this.locator.tryGetInstance(DeadLetterQueueRunnerMoniker);
   }
   async startHandler() {
     await super.startHandler();
     this.registerTimer("ValidatorActor", async () => {
       await this.spanAsync("processPendingBlocks", async () => {
-        console.log("ValidatorActor: Processing pending blocks...");
+        this.logger?.debug("ValidatorActor: Processing pending blocks...");
         await processPendingBlocks({
           blockValidationViewer: this.blockValidationViewer,
           context: this.context,
@@ -56,7 +61,9 @@ var ValidatorActor = class extends ActorV3 {
           mempoolViewer: this.mempoolViewer,
           blockViewer: this.blockViewer,
           finalizationRunner: this.finalizationRunner,
-          allowedProducers: this.allowedProducers
+          allowedProducers: this.allowedProducers,
+          minCandidates: this.minCandidates,
+          deadLetterQueueRunner: this._deadLetterQueueRunner
         });
       }, {
         ...this.context,
@@ -91,13 +98,24 @@ __name(buildTelemetryConfig, "buildTelemetryConfig");
 // src/shared/config/actors/Api.ts
 import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/sdk-js";
 import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+
+// src/shared/config/actors/accountIndex.ts
 import { globalRegistry, z } from "zod";
-var ApiConfigZod = HostActorConfigZod.extend(z.object({
-  initRewardsCache: z.union([
-    z.number(),
-    z.string(),
-    z.boolean()
-  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry, {
+var ActorAccountIndexZod = /* @__PURE__ */ __name((title) => z.coerce.number().int().min(0).optional().register(globalRegistry, {
+  description: "Account index derived from the actor wallet phrase. Defaults to 0 for actor mnemonics and to the actor-specific shared index for the root mnemonic.",
+  title,
+  type: "number"
+}), "ActorAccountIndexZod");
+
+// src/shared/config/actors/Api.ts
+var ApiConfigZod = HostActorConfigZod.extend(z2.object({
+  accountIndex: ActorAccountIndexZod("api.accountIndex"),
+  initRewardsCache: z2.union([
+    z2.number(),
+    z2.string(),
+    z2.boolean()
+  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry2, {
     description: "Whether to initialize the rewards cache on startup",
     title: "api.initRewardsCache",
     type: "boolean"
@@ -116,7 +134,7 @@ var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
 // 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";
+import { globalRegistry as globalRegistry3, z as z3 } from "zod";
 var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
 var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
@@ -125,83 +143,84 @@ var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex("0xac0974bec39a17e36
 var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f64180aa3");
 var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(1000000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
-var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
+var BasisPointsZod = z3.coerce.number().int().nonnegative().max(1e4);
 var BridgeConfigZod = HostActorConfigZod2.extend({
-  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+  accountIndex: ActorAccountIndexZod("bridge.accountIndex"),
+  escrowAddress: AddressZod.optional().register(globalRegistry3, {
     description: "Address to which bridge escrow will be sent",
     title: "bridge.escrowAddress",
     type: "string"
   }),
-  feesAddress: AddressZod.optional().register(globalRegistry2, {
+  feesAddress: AddressZod.optional().register(globalRegistry3, {
     description: "Address to which bridge fees will be sent",
     title: "bridge.feesAddress",
     type: "string"
   }),
-  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry2, {
+  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry3, {
     default: DEFAULT_FIXED_FEE,
     description: "Fixed fee (in AttoXL1) applied to bridge transfers",
     title: "bridge.feeFixed",
     type: "bigint"
   }),
-  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry3, {
     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"
   }),
-  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
+  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry3, {
     default: DEFAULT_MAX_BRIDGE_AMOUNT,
     description: "Maximum amount allowed for a bridge transfer",
     title: "bridge.maxBridgeAmount",
     type: "string"
   }),
-  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry2, {
+  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry3, {
     default: DEFAULT_MIN_BRIDGE_AMOUNT,
     description: "Minimum amount required for a bridge transfer",
     title: "bridge.minBridgeAmount",
     type: "string"
   }),
-  redisHost: z2.string().default("localhost").register(globalRegistry2, {
+  redisHost: z3.string().default("localhost").register(globalRegistry3, {
     default: "localhost",
     description: "Host for the Bridge Redis instance",
     title: "bridge.redisHost",
     type: "string"
   }),
-  redisPort: z2.coerce.number().int().positive().default(6379).register(globalRegistry2, {
+  redisPort: z3.coerce.number().int().positive().default(6379).register(globalRegistry3, {
     default: 6379,
     description: "Port for the Bridge Redis instance",
     title: "bridge.redisPort",
     type: "number"
   }),
-  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
+  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry3, {
     default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteBridgeContractAddress",
     type: "string"
   }),
-  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
+  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry3, {
     default: DEFAULT_HARDHAT_CHAIN_ID,
     description: "Remote chain ID",
     title: "bridge.remoteChainId",
     type: "string"
   }),
-  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
+  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry3, {
     default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteTokenAddress",
     type: "string"
   }),
-  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
+  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry3, {
     description: "Private key for the wallet to use for the remote chain wallet",
     title: "bridge.remoteChainWalletPrivateKey",
     type: "string"
   }),
-  xl1ChainId: HexZod.optional().register(globalRegistry2, {
+  xl1ChainId: HexZod.optional().register(globalRegistry3, {
     description: "XL1 chain id used for bridging",
     title: "bridge.xl1ChainId",
     type: "string"
   }),
-  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
+  xl1TokenAddress: HexZod.optional().register(globalRegistry3, {
     description: "XL1 token address used for bridging",
     title: "bridge.xl1TokenAddress",
     type: "string"
@@ -232,11 +251,12 @@ var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigCo
 // 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";
+import { globalRegistry as globalRegistry4, z as z4 } from "zod";
 var MempoolConfigZod = HostActorConfigZod3.extend({
-  enabled: z3.union([
-    z3.string(),
-    z3.boolean()
+  accountIndex: ActorAccountIndexZod("mempool.accountIndex"),
+  enabled: z4.union([
+    z4.string(),
+    z4.boolean()
   ]).default("false").transform((val, ctx) => {
     if (typeof val === "boolean") return val;
     const normalized = val.toLowerCase().trim();
@@ -257,8 +277,8 @@ var MempoolConfigZod = HostActorConfigZod3.extend({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z3.NEVER;
-  }).register(globalRegistry3, {
+    return z4.NEVER;
+  }).register(globalRegistry4, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
@@ -278,36 +298,43 @@ var toMempoolConfigContext = zodToFactory3(MempoolConfigContext, "toMempoolConfi
 // 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({
-  allowlist: z4.preprocess((val) => {
+import { globalRegistry as globalRegistry5, z as z5 } from "zod";
+var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
+var ProducerConfigZod = ActorConfigZod.extend(z5.object({
+  accountIndex: ActorAccountIndexZod("producer.accountIndex"),
+  allowlist: z5.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z4.array(AddressZod2).optional().register(globalRegistry4, {
+  }, z5.array(AddressZod2).optional().register(globalRegistry5, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  disableIntentRedeclaration: z4.boolean().optional().register(globalRegistry4, {
+  blockProductionCheckInterval: z5.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry5, {
+    description: "The interval time (in milliseconds) between block production attempts",
+    title: "producer.blockProductionCheckInterval",
+    type: "number"
+  }),
+  disableIntentRedeclaration: z5.boolean().optional().register(globalRegistry5, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
-  heartbeatInterval: z4.coerce.number().default(36e5).register(globalRegistry4, {
+  heartbeatInterval: z5.coerce.number().default(36e5).register(globalRegistry5, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z4.coerce.number().default(1).register(globalRegistry4, {
+  minStake: z5.coerce.number().default(1).register(globalRegistry5, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z4.string().optional().register(globalRegistry4, {
+  rewardAddress: z5.string().optional().register(globalRegistry5, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -326,7 +353,9 @@ var toProducerConfigContext = zodToFactory4(ProducerConfigContext, "toProducerCo
 // 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 RewardRedemptionConfigZod = HostActorConfigZod4.extend({
+  accountIndex: ActorAccountIndexZod("rewardRedemption.accountIndex")
+});
 var isRewardRedemptionConfig = zodIsFactory5(RewardRedemptionConfigZod);
 var asRewardRedemptionConfig = zodAsFactory5(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
 var toRewardRedemptionConfig = zodToFactory5(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
@@ -340,9 +369,11 @@ var toRewardRedemptionConfigContext = zodToFactory5(RewardRedemptionConfigContex
 // src/shared/config/actors/Validator.ts
 import { AddressZod as AddressZod3, zodAsFactory as zodAsFactory6, zodIsFactory as zodIsFactory6, zodToFactory as zodToFactory6 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod6, HostActorConfigZod as HostActorConfigZod5 } from "@xyo-network/xl1-sdk";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var ValidatorConfigZod = HostActorConfigZod5.extend({
-  allowedProducers: z5.array(AddressZod3).optional()
+  accountIndex: ActorAccountIndexZod("validator.accountIndex"),
+  allowedProducers: z6.array(AddressZod3).optional(),
+  minCandidates: z6.number().int().min(0).optional()
 });
 var isValidatorConfig = zodIsFactory6(ValidatorConfigZod);
 var asValidatorConfig = zodAsFactory6(ValidatorConfigZod, "asValidatorConfig");
@@ -419,26 +450,279 @@ var ServiceLifetime = {
 };
 
 // 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";
+import { isDefined } from "@xylabs/sdk-js";
+
+// src/shared/init/walletResolution.ts
+import { DEFAULT_WALLET_PATH, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+var BUILT_IN_DEV_MNEMONIC = "crane ribbon cook cousin tobacco vital moral protect merit knock veteran hint knee ocean nurse";
+var INSECURE_GENESIS_REWARD_MNEMONIC = "test test test test test test test test test test test junk";
+var GENESIS_REWARD_AMOUNT = 20000000000000000000000n;
+var ATTO_XL1_PER_XL1 = 1000000000000000000n;
+var ROOT_WALLET_RUNTIME_ID = "_root";
+var SHARED_ACCOUNT_REPORT_COUNT = 10;
+var RESERVED_ACTOR_INDEX = {
+  [ROOT_WALLET_RUNTIME_ID]: 0,
+  api: 4,
+  bridge: 2,
+  mempool: 5,
+  producer: 1,
+  rewardRedemption: 3,
+  validator: 6
+};
+var ACTOR_LABELS = {
+  [ROOT_WALLET_RUNTIME_ID]: "root/local-node",
+  api: "api",
+  bridge: "bridge",
+  mempool: "mempool",
+  producer: "producer",
+  rewardRedemption: "rewardRedemption",
+  validator: "validator"
+};
+var activeWalletReport;
+function getAccountLabel(actorName) {
+  return ACTOR_LABELS[actorName] ?? actorName;
+}
+__name(getAccountLabel, "getAccountLabel");
+function clearResolvedWalletReport() {
+  activeWalletReport = void 0;
+}
+__name(clearResolvedWalletReport, "clearResolvedWalletReport");
+function getReservedActorIndex(actorName) {
+  return RESERVED_ACTOR_INDEX[actorName] ?? 0;
+}
+__name(getReservedActorIndex, "getReservedActorIndex");
+function getBuiltInDevMnemonic() {
+  return BUILT_IN_DEV_MNEMONIC;
+}
+__name(getBuiltInDevMnemonic, "getBuiltInDevMnemonic");
+function getInsecureGenesisRewardMnemonic() {
+  return INSECURE_GENESIS_REWARD_MNEMONIC;
+}
+__name(getInsecureGenesisRewardMnemonic, "getInsecureGenesisRewardMnemonic");
+function resolveRootWallet(configuration) {
+  const mnemonic = configuration.mnemonic ?? BUILT_IN_DEV_MNEMONIC;
+  const isBuiltInDevMnemonic = mnemonic === BUILT_IN_DEV_MNEMONIC;
+  return {
+    basePath: DEFAULT_WALLET_PATH,
+    isBuiltInDevMnemonic,
+    mnemonic,
+    mnemonicKind: isBuiltInDevMnemonic ? "built-in-dev" : "configured-root"
+  };
+}
+__name(resolveRootWallet, "resolveRootWallet");
+async function resolveWalletMetadata({ accountIndex, actorName, mnemonic, mnemonicKind, source }) {
+  const wallet = await generateXyoBaseWalletFromPhrase(mnemonic);
+  const derivationPath = `${DEFAULT_WALLET_PATH}/${accountIndex}`;
+  const account = await wallet.derivePath(`${accountIndex}`);
+  return {
+    accountIndex,
+    actorName,
+    address: account.address,
+    derivationPath,
+    label: getAccountLabel(actorName),
+    mnemonic,
+    mnemonicKind,
+    privateKey: account.privateKey,
+    source,
+    usesBuiltInDevMnemonic: mnemonic === BUILT_IN_DEV_MNEMONIC
+  };
+}
+__name(resolveWalletMetadata, "resolveWalletMetadata");
+async function resolveActorWallet(actorName, actorConfig, root) {
+  const actorMnemonic = actorConfig?.mnemonic;
+  const accountIndex = actorConfig?.accountIndex;
+  return await resolveWalletMetadata(actorMnemonic ? {
+    accountIndex: accountIndex ?? 0,
+    actorName,
+    mnemonic: actorMnemonic,
+    mnemonicKind: "configured-actor",
+    source: "actor"
+  } : {
+    accountIndex: accountIndex ?? getReservedActorIndex(actorName),
+    actorName,
+    mnemonic: root.mnemonic,
+    mnemonicKind: root.mnemonicKind,
+    source: "root"
+  });
+}
+__name(resolveActorWallet, "resolveActorWallet");
+async function resolveWalletReport(requestedActors, configuration) {
+  const root = resolveRootWallet(configuration);
+  const actorConfigMap = new Map(configuration.actors.map((actor) => [
+    actor.name,
+    actor
+  ]));
+  const resolvedActors = await Promise.all(requestedActors.map(async (actorName) => await resolveActorWallet(actorName, actorConfigMap.get(actorName), root)));
+  const labelMap = /* @__PURE__ */ new Map([
+    [
+      0,
+      [
+        getAccountLabel(ROOT_WALLET_RUNTIME_ID)
+      ]
+    ]
+  ]);
+  for (const actor of resolvedActors) {
+    if (actor.source !== "root") continue;
+    const labels = labelMap.get(actor.accountIndex) ?? [];
+    labels.push(actor.label);
+    labelMap.set(actor.accountIndex, labels);
+  }
+  const sharedAccounts = await Promise.all(Array.from({
+    length: SHARED_ACCOUNT_REPORT_COUNT
+  }, (_, index) => index).map(async (accountIndex) => {
+    const account = await resolveWalletMetadata({
+      accountIndex,
+      actorName: ROOT_WALLET_RUNTIME_ID,
+      mnemonic: root.mnemonic,
+      mnemonicKind: root.mnemonicKind,
+      source: "root"
+    });
+    const labels = labelMap.get(accountIndex);
+    return {
+      ...account,
+      label: labels?.join(", ") ?? `shared[${accountIndex}]`
+    };
+  }));
+  const insecureGenesisRewardAccounts = configuration.chain.genesisRewardAddress ? void 0 : await Promise.all(Array.from({
+    length: SHARED_ACCOUNT_REPORT_COUNT
+  }, (_, index) => index).map(async (accountIndex) => {
+    const account = await resolveWalletMetadata({
+      accountIndex,
+      actorName: "genesisReward",
+      mnemonic: INSECURE_GENESIS_REWARD_MNEMONIC,
+      mnemonicKind: "configured-actor",
+      source: "actor"
+    });
+    return {
+      ...account,
+      label: accountIndex === 0 ? "genesisRewardAddress" : `genesisReward[${accountIndex}]`
+    };
+  }));
+  return {
+    actorSpecificAccounts: resolvedActors.filter((actor) => actor.source === "actor"),
+    insecureGenesisRewardAccounts,
+    requestedActors: [
+      ...requestedActors
+    ],
+    root,
+    sharedAccounts
+  };
+}
+__name(resolveWalletReport, "resolveWalletReport");
+async function initializeResolvedWalletReport(requestedActors, configuration) {
+  activeWalletReport = await resolveWalletReport(requestedActors, configuration);
+  return activeWalletReport;
+}
+__name(initializeResolvedWalletReport, "initializeResolvedWalletReport");
+function getResolvedWalletReport() {
+  return activeWalletReport;
+}
+__name(getResolvedWalletReport, "getResolvedWalletReport");
+function formatSharedAccount(account, showPrivateKey) {
+  const lines = [
+    `[${account.accountIndex}] ${account.label}`,
+    `source: ${account.mnemonicKind === "built-in-dev" ? "built-in dev mnemonic" : "configured root mnemonic"}`,
+    `path: ${account.derivationPath}`,
+    `address: ${account.address}`
+  ];
+  if (showPrivateKey) lines.push(`privateKey: ${account.privateKey ?? "unavailable"}`);
+  return lines.join("\n");
+}
+__name(formatSharedAccount, "formatSharedAccount");
+function formatActorSpecificAccount(account) {
+  return [
+    account.label,
+    "source: actor mnemonic",
+    `path: ${account.derivationPath}`,
+    `address: ${account.address}`
+  ].join("\n");
+}
+__name(formatActorSpecificAccount, "formatActorSpecificAccount");
+function formatGenesisRewardAccount(account) {
+  const balance = account.accountIndex === 0 ? GENESIS_REWARD_AMOUNT / ATTO_XL1_PER_XL1 : 0n;
+  return [
+    `[${account.accountIndex}] ${account.label}`,
+    `path: ${account.derivationPath}`,
+    `address: ${account.address}`,
+    `privateKey: ${account.privateKey ?? "unavailable"}`,
+    `balance: ${balance.toString()} XL1`
+  ].join("\n");
+}
+__name(formatGenesisRewardAccount, "formatGenesisRewardAccount");
+function formatWalletReport(report) {
+  const sections = [];
+  const showSecrets = report.root.isBuiltInDevMnemonic;
+  sections.push(showSecrets ? "Development wallet detected." : "Wallet summary");
+  if (showSecrets) {
+    sections.push([
+      "DEVELOPMENT WALLET WARNING",
+      "",
+      "XL1 is using the built-in development mnemonic.",
+      "This mnemonic is fixed, public, and does not change between runs.",
+      "The addresses and private keys below are unsafe and must never be used for real funds, production systems, or shared environments.",
+      "Anyone with this information can fully control these accounts.",
+      "",
+      "Mnemonic:",
+      report.root.mnemonic
+    ].join("\n"));
+  }
+  sections.push([
+    `Shared wallet accounts from ${report.root.basePath}:`,
+    "",
+    report.sharedAccounts.map((account) => formatSharedAccount(account, showSecrets)).join("\n\n")
+  ].join("\n"));
+  if (report.actorSpecificAccounts.length > 0) {
+    sections.push([
+      "Actor-specific wallet accounts:",
+      "",
+      report.actorSpecificAccounts.map((account) => formatActorSpecificAccount(account)).join("\n\n")
+    ].join("\n"));
+  }
+  if (report.insecureGenesisRewardAccounts) {
+    sections.push([
+      "INSECURE GENESIS REWARD WALLET WARNING",
+      "",
+      "XL1 is using a public, insecure fallback wallet for the genesis reward address.",
+      "This phrase is intentionally unsafe and must never be used for real funds, production systems, or shared environments.",
+      "Anyone with this information can fully control the genesis reward wallet.",
+      "",
+      "Genesis reward phrase:",
+      INSECURE_GENESIS_REWARD_MNEMONIC,
+      "",
+      `The genesis reward is sent to index 0 and starts with ${(GENESIS_REWARD_AMOUNT / ATTO_XL1_PER_XL1).toString()} XL1.`,
+      "",
+      `Genesis reward wallet accounts from ${DEFAULT_WALLET_PATH}:`,
+      "",
+      report.insecureGenesisRewardAccounts.map((account) => formatGenesisRewardAccount(account)).join("\n\n")
+    ].join("\n"));
+  }
+  return sections.join("\n\n");
+}
+__name(formatWalletReport, "formatWalletReport");
+async function resolveGenesisRewardAddress(config) {
+  if (config.chain.genesisRewardAddress) return config.chain.genesisRewardAddress;
+  const wallet = await generateXyoBaseWalletFromPhrase(INSECURE_GENESIS_REWARD_MNEMONIC);
+  const account = await wallet.derivePath("0");
+  return account.address;
+}
+__name(resolveGenesisRewardAddress, "resolveGenesisRewardAddress");
+async function resolveWalletForActor(actorName, mnemonic, accountIndex) {
+  const fromReport = activeWalletReport ? actorName === ROOT_WALLET_RUNTIME_ID ? activeWalletReport.sharedAccounts.find((account) => account.accountIndex === 0) : activeWalletReport.actorSpecificAccounts.find((account) => account.actorName === actorName) ?? activeWalletReport.sharedAccounts.find((account) => account.actorName === actorName || account.label.split(", ").includes(getAccountLabel(actorName))) : void 0;
+  const resolvedMnemonic = fromReport?.mnemonic ?? mnemonic ?? BUILT_IN_DEV_MNEMONIC;
+  const resolvedAccountIndex = fromReport?.accountIndex ?? accountIndex ?? 0;
+  const wallet = await generateXyoBaseWalletFromPhrase(resolvedMnemonic);
+  return await wallet.derivePath(`${resolvedAccountIndex}`);
+}
+__name(resolveWalletForActor, "resolveWalletForActor");
+
+// src/shared/init/initActorAccount.ts
 var actorAccountSingletons = {};
 async function initActorAccount({ config, logger }) {
   const actorName = config.name;
   if (isDefined(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
-  let walletPhrase = config.mnemonic;
-  if (isUndefined(walletPhrase)) {
-    logger?.warn(`[${actorName}}] No wallet mnemonic specified!`);
-    const randomMnemonic = HDWallet.generateMnemonic();
-    logger?.warn(`[${actorName}}] Using randomly generated mnemonic:
-    
-${randomMnemonic}
-      
-    `);
-    walletPhrase = randomMnemonic;
-  }
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  const accountIndex = "accountIndex" in config && typeof config.accountIndex === "number" ? config.accountIndex : void 0;
+  const account = await resolveWalletForActor(actorName, config.mnemonic, accountIndex);
+  logger?.debug(`[${actorName}] Using wallet address ${account.address}`);
   actorAccountSingletons[actorName] = account;
   return actorAccountSingletons[actorName];
 }
@@ -446,28 +730,18 @@ __name(initActorAccount, "initActorAccount");
 
 // 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 (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 (isString(mnemonic)) {
-      seedPhrase = mnemonic;
-    } else {
-      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 assertEx(await bios.seedPhraseStore.get(walletKind), () => "Unable to acquire mnemonic from bios");
+  void bios;
+  const report = getResolvedWalletReport();
+  const account = config.name === ROOT_WALLET_RUNTIME_ID ? report?.sharedAccounts.find((entry) => entry.accountIndex === 0) : report?.actorSpecificAccounts.find((entry) => entry.actorName === config.name);
+  if (isString(account?.mnemonic)) return account.mnemonic;
+  if (isString(report?.root.mnemonic)) return report.root.mnemonic;
+  if (isString(config.mnemonic)) return config.mnemonic;
+  const fallback = getBuiltInDevMnemonic();
+  logger?.debug(`[${walletKind}] Falling back to built-in development mnemonic`);
+  return assertEx(fallback, () => "Unable to resolve mnemonic");
 }
 __name(initActorSeedPhrase, "initActorSeedPhrase");
 
@@ -521,13 +795,10 @@ function initStatusReporter({ logger }) {
 __name(initStatusReporter, "initStatusReporter");
 
 // src/shared/init/initWallet.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet3 } from "@xyo-network/sdk-js";
 async function initActorWallet(context, mnemonic) {
-  const bios = await boot();
-  const seedPhrase = isDefined2(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
-  return await HDWallet3.fromPhrase(seedPhrase);
+  const actorName = context.config.name === ROOT_WALLET_RUNTIME_ID ? ROOT_WALLET_RUNTIME_ID : context.config.name;
+  const accountIndex = "accountIndex" in context.config && typeof context.config.accountIndex === "number" ? context.config.accountIndex : void 0;
+  return await resolveWalletForActor(actorName, mnemonic ?? context.config.mnemonic, accountIndex);
 }
 __name(initActorWallet, "initActorWallet");
 
@@ -596,177 +867,6 @@ Orchestrator = _ts_decorate2([
   creatable2()
 ], Orchestrator);
 
-// src/node/archivists/ChainFinalized/archivist.ts
-import { timeBudget } from "@xylabs/sdk-js";
-import { startupSpanAsync } from "@xyo-network/chain-utils";
-import { Mutex as Mutex3 } from "async-mutex";
-
-// src/node/archivists/ChainFinalized/local.ts
-import { Mutex as Mutex2 } from "async-mutex";
-
-// src/node/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/node/archivists/ChainFinalized/local.ts
-var mutex = new Mutex2();
-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/node/archivists/ChainFinalized/archivist.ts
-var mutex2 = new Mutex3();
-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/node/archivists/PendingBlocks/archivist.ts
-import { timeBudget as timeBudget2 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync2 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex5 } from "async-mutex";
-
-// src/node/archivists/PendingBlocks/local.ts
-import { Mutex as Mutex4 } from "async-mutex";
-var mutex3 = new Mutex4();
-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/node/archivists/PendingBlocks/archivist.ts
-var mutex4 = new Mutex5();
-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/node/archivists/RejectedTransactions/archivist.ts
-import { timeBudget as timeBudget3 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync3 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex7 } from "async-mutex";
-
-// src/node/archivists/RejectedTransactions/local.ts
-import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/sdk-js";
-import { Mutex as Mutex6 } from "async-mutex";
-var mutex5 = new Mutex6();
-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/node/archivists/RejectedTransactions/archivist.ts
-var mutex6 = new Mutex7();
-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/node/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx4, timeBudget as timeBudget4 } from "@xylabs/sdk-js";
-import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
-import { Mutex as Mutex9 } from "async-mutex";
-
-// src/node/archivists/StakeIntentState/local.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
-import { Mutex as Mutex8 } from "async-mutex";
-var mutex7 = new Mutex8();
-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 assertEx3(singleton7, () => new Error("Failed to initialize stake intent state archivist"));
-  });
-}
-__name(initLocalStakeIntentStateArchivist, "initLocalStakeIntentStateArchivist");
-
-// src/node/archivists/StakeIntentState/archivist.ts
-var mutex8 = new Mutex9();
-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 assertEx4(singleton8, () => "StakeIntentStateArchivist is undefined");
-    }, 2e3, true);
-  });
-}
-__name(initStakeIntentStateArchivist, "initStakeIntentStateArchivist");
-
 // src/node/config/locators/basicRemoteRunnerLocator.ts
 import { isAccountInstance } from "@xyo-network/sdk-js";
 import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator, JsonRpcAccountBalanceViewer, JsonRpcXyoSigner, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
@@ -845,14 +945,14 @@ async function contextFromConfigWithoutLocator(config, logger, serviceName, serv
 __name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
 
 // src/node/config/locators/localLocatorFromConfig.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
-import { BlockCumulativeBalanceValidatorFactory, ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer } from "@xyo-network/xl1-sdk";
+import { BlockCumulativeBalanceValidatorFactory, ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleDeadLetterQueueRunner, SimpleDeadLetterQueueViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionValidationViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer, validateTransaction } from "@xyo-network/xl1-sdk";
 
 // src/node/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
-import { MongoMap } from "@xyo-network/chain-protocol";
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { MongoMap } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
 async function initBalanceSummaryMap({ logger, config }) {
   const mongoConfig = config.storage?.mongo;
@@ -876,7 +976,7 @@ async function initBalanceSummaryMap({ logger, config }) {
         maxEntries: 5e3
       }
     });
-    assertEx5(await result.start(), () => "Failed to start transfer summary map");
+    assertEx3(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -886,118 +986,35 @@ async function initBalanceSummaryMap({ logger, config }) {
 __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/node/init/initEvmProvidersIfAvailable.ts
-import { asEthAddress, assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { asEthAddress } from "@xylabs/sdk-js";
 import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
+import { canUseEvmProvider, initEvmProvider } from "@xyo-network/chain-orchestration-evm";
 import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
-
-// src/node/evm/initChainId.ts
-import { assertEx as assertEx6, hexFrom, isDefined as isDefined3, isHex } from "@xylabs/sdk-js";
-var canUseChainId = /* @__PURE__ */ __name(({ config }) => {
-  return isDefined3(config.evm.chainId);
-}, "canUseChainId");
-var getChainId = /* @__PURE__ */ __name(({ config }) => {
-  const chainId = assertEx6(config.evm.chainId, () => "Missing config.evm.chainId");
-  if (isHex(chainId, {
-    prefix: true
-  })) {
-    const hex = hexFrom(chainId);
-    const parsed = Number.parseInt(hex, 16);
-    return parsed;
-  } else {
-    const parsed = Number.parseInt(chainId, 10);
-    return parsed;
-  }
-}, "getChainId");
-
-// src/node/evm/initEvmProvider.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
-
-// src/node/evm/initInfuraProvider.ts
-import { assertEx as assertEx7, isDefined as isDefined4 } from "@xylabs/sdk-js";
-import { InfuraProvider } from "ethers/providers";
-var instance;
-var initInfuraProvider = /* @__PURE__ */ __name((context) => {
-  if (instance) return instance;
-  const providerConfig = getInfuraProviderConfig(context);
-  instance = Promise.resolve(new InfuraProvider(providerConfig[0], providerConfig[1]));
-  return instance;
-}, "initInfuraProvider");
-var canUseInfuraProvider = /* @__PURE__ */ __name((context) => {
-  const { config } = context;
-  return canUseChainId(context) && isDefined4(config.evm?.infura?.projectId) && isDefined4(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");
-  return [
-    getChainId(context),
-    projectId,
-    projectSecret
-  ];
-}, "getInfuraProviderConfig");
-
-// src/node/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx8, isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { JsonRpcProvider } from "ethers/providers";
-var initJsonRpcProvider = /* @__PURE__ */ __name((context) => {
-  const providerConfig = getJsonRpcProviderConfig(context);
-  return Promise.resolve(new JsonRpcProvider(...providerConfig));
-}, "initJsonRpcProvider");
-var canUseJsonRpcProvider = /* @__PURE__ */ __name((context) => {
-  const { config } = context;
-  return canUseChainId(context) && isDefined5(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");
-  return [
-    jsonRpcUrl,
-    getChainId(context)
-  ];
-}, "getJsonRpcProviderConfig");
-
-// src/node/evm/initEvmProvider.ts
-var provider;
-var initEvmProvider = /* @__PURE__ */ __name(async (context) => {
-  if (provider) return provider;
-  if (canUseInfuraProvider(context)) {
-    provider = initInfuraProvider(context);
-  } else if (canUseJsonRpcProvider(context)) {
-    provider = initJsonRpcProvider(context);
-  }
-  return assertEx9(await provider, () => "No provider available");
-}, "initEvmProvider");
-var canUseEvmProvider = /* @__PURE__ */ __name((context) => {
-  return canUseInfuraProvider(context) || canUseJsonRpcProvider(context);
-}, "canUseEvmProvider");
-
-// src/node/init/initEvmProvidersIfAvailable.ts
 async function initEvmProvidersIfAvailable(locator) {
   const context = locator.context;
   const { logger } = context;
-  if (canUseEvmProvider(context)) {
-    const chainId = assertEx10(context.config.chain.id, () => "Missing config.chain.id (required for EVM providers)");
-    const provider2 = await initEvmProvider(context);
+  if (canUseEvmProvider(context) && context.config.chain.id) {
+    const chainId = context.config.chain.id;
+    const provider = await initEvmProvider(context);
     const address = asEthAddress(chainId, true);
     locator.register(EvmStakeEventsViewer.factory(EvmStakeEventsViewer.dependencies, {
       address,
-      provider: provider2
+      provider
     }));
     locator.register(EvmStakeViewer.factory(EvmStakeViewer.dependencies, {
       address,
-      provider: provider2
+      provider
     }));
     locator.register(EvmStakeTotalsViewer.factory(EvmStakeTotalsViewer.dependencies, {
       address,
-      provider: provider2
+      provider
     }));
     locator.register(EvmChainContractViewer.factory(EvmChainContractViewer.dependencies, {
       address,
-      provider: provider2
+      provider
     }));
     locator.register(SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {
-      ethProvider: provider2
+      ethProvider: provider
     }));
   } else {
     logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
@@ -1021,7 +1038,7 @@ async function initEvmProvidersIfAvailable(locator) {
 __name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
 // src/node/init/initFinalizationArchivistIfNeeded.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx4 } 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";
@@ -1034,12 +1051,13 @@ async function initFinalizationArchivistIfNeeded(archivist, config, account) {
   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 genesisRewardAddress = await resolveGenesisRewardAddress(config);
+    const chain = await createBootstrapHead(account, possibleChainId, asAttoXL1(GENESIS_REWARD_AMOUNT), genesisRewardAddress);
     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");
+  const head = possibleHead ?? assertEx4(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
+  const chainId = assertEx4(possibleChainId, () => "Chain ID could not be determined");
   return [
     head,
     chainId
@@ -1066,15 +1084,15 @@ async function initFinalizedArchivist(config) {
 __name(initFinalizedArchivist, "initFinalizedArchivist");
 
 // src/node/init/initServerNode.ts
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/sdk-js";
 
 // src/node/manifest/getLocator.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { MongoDBArchivistV2 as MongoDBArchivistV22, MongoDBArchivistV2Deletable } from "@xyo-network/archivist-mongodb";
 import { ViewArchivist } from "@xyo-network/archivist-view";
 import { initTelemetry as initTelemetry2 } from "@xyo-network/chain-telemetry";
-import { AbstractModule, LoggerModuleStatusReporter, MemoryArchivist as MemoryArchivist2, MemorySentinel, ModuleFactoryLocator } from "@xyo-network/sdk-js";
+import { AbstractModule, LoggerModuleStatusReporter, MemoryArchivist, MemorySentinel, ModuleFactoryLocator } from "@xyo-network/sdk-js";
 import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-sdk";
 var getLocator = /* @__PURE__ */ __name(async ({ logger, config }) => {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
@@ -1090,7 +1108,7 @@ var getLocator = /* @__PURE__ */ __name(async ({ logger, config }) => {
       port
     }
   });
-  if (isDefined6(logger)) AbstractModule.defaultLogger = logger;
+  if (isDefined2(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
@@ -1114,7 +1132,7 @@ var getLocator = /* @__PURE__ */ __name(async ({ logger, config }) => {
       "network.xyo.storage.capabilities.delete": "enabled"
     }, false);
   }
-  locator.register(MemoryArchivist2.factory({
+  locator.register(MemoryArchivist.factory({
     traceProvider,
     meterProvider,
     statusReporter
@@ -1211,6 +1229,62 @@ var Chain_default = {
   schema: "network.xyo.manifest"
 };
 
+// src/node/manifest/public/DeadLetterQueue.json
+var DeadLetterQueue_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "3",
+        name: "DeadLetterQueue",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: [
+          {
+            config: {
+              accountPath: "3/1/1",
+              name: "RejectedBlocks",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              labels: {
+                "network.xyo.storage.capabilities.delete": "enabled",
+                "network.xyo.storage.class": "mongodb"
+              },
+              payloadSdkConfig: {
+                collection: "rejected_blocks"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "3/1/2",
+              name: "RejectedTransactions",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              labels: {
+                "network.xyo.storage.capabilities.delete": "enabled",
+                "network.xyo.storage.class": "mongodb"
+              },
+              payloadSdkConfig: {
+                collection: "rejected_transactions"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
 // src/node/manifest/public/Pending.json
 var Pending_default = {
   $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
@@ -1269,9 +1343,11 @@ var Pending_default = {
 
 // src/node/manifest/public/index.ts
 var ChainNodeManifest = Chain_default;
+var DeadLetterQueueNodeManifest = DeadLetterQueue_default;
 var PendingNodeManifest = Pending_default;
 var PublicChildManifests = [
   ...ChainNodeManifest.nodes,
+  ...DeadLetterQueueNodeManifest.nodes,
   ...PendingNodeManifest.nodes
 ];
 
@@ -1295,7 +1371,7 @@ async function writableChainArchivistFromNode(node) {
 }
 __name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx12(asArchivistInstance(await node.resolve("Chain:Validated"), {
+  return assertEx5(asArchivistInstance(await node.resolve("Chain:Validated"), {
     required: true
   }));
 }
@@ -1312,27 +1388,43 @@ async function pendingBlocksArchivistFromNode(node) {
   });
 }
 __name(pendingBlocksArchivistFromNode, "pendingBlocksArchivistFromNode");
+async function rejectedBlocksArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("XYOChain:DeadLetterQueue:RejectedBlocks"), {
+    required: true
+  });
+}
+__name(rejectedBlocksArchivistFromNode, "rejectedBlocksArchivistFromNode");
+async function rejectedTransactionsArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("XYOChain:DeadLetterQueue:RejectedTransactions"), {
+    required: true
+  });
+}
+__name(rejectedTransactionsArchivistFromNode, "rejectedTransactionsArchivistFromNode");
 async function initServerNode(context, wallet, providedNode) {
   const node = providedNode ?? await loadNode(context, wallet);
-  assertEx12(await node.start(), () => "Failed to start node");
+  assertEx5(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);
+  const rejectedBlocksArchivist = await rejectedBlocksArchivistFromNode(node);
+  const rejectedTransactionsArchivist = await rejectedTransactionsArchivistFromNode(node);
   return {
     node,
     writableChainArchivist,
     readonlyChainArchivist,
     pendingTransactionsArchivist,
-    pendingBlocksArchivist
+    pendingBlocksArchivist,
+    rejectedBlocksArchivist,
+    rejectedTransactionsArchivist
   };
 }
 __name(initServerNode, "initServerNode");
 
 // src/node/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 { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-sdk";
 async function initTransferSummaryMap({ logger, config }) {
   const mongoConfig = config.storage?.mongo;
@@ -1356,7 +1448,7 @@ async function initTransferSummaryMap({ logger, config }) {
         maxEntries: 5e3
       }
     });
-    assertEx13(await result.start(), () => "Failed to start transfer summary map");
+    assertEx6(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1378,10 +1470,10 @@ var validateHydratedBlockStateWithCumulativeBalance = /* @__PURE__ */ __name(asy
   ];
 }, "validateHydratedBlockStateWithCumulativeBalance");
 async function localLocatorFromConfig(context, validateDepsOnRegister = false) {
-  const balancesSummaryMap = assertEx14(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
-  const transfersSummaryMap = assertEx14(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
+  const balancesSummaryMap = assertEx7(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
+  const transfersSummaryMap = assertEx7(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
   const wallet = await initActorWallet(context);
-  const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist } = await initServerNode(context, wallet);
+  const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist, rejectedBlocksArchivist, rejectedTransactionsArchivist } = await initServerNode(context, wallet);
   await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet);
   const locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister);
   locator.registerMany([
@@ -1419,6 +1511,17 @@ async function localLocatorFromConfig(context, validateDepsOnRegister = false) {
     SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
       state: validateHydratedBlockStateWithCumulativeBalance,
       protocol: validateHydratedBlock
+    }),
+    SimpleTransactionValidationViewer.factory(SimpleTransactionValidationViewer.dependencies, {
+      protocol: validateTransaction
+    }),
+    SimpleDeadLetterQueueRunner.factory(SimpleDeadLetterQueueRunner.dependencies, {
+      rejectedBlocksArchivist,
+      rejectedTransactionsArchivist
+    }),
+    SimpleDeadLetterQueueViewer.factory(SimpleDeadLetterQueueViewer.dependencies, {
+      rejectedBlocksArchivist,
+      rejectedTransactionsArchivist
     })
   ]);
   return locator;
@@ -1427,7 +1530,6 @@ __name(localLocatorFromConfig, "localLocatorFromConfig");
 
 // src/node/config/locators/locatorsFromConfig.ts
 import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
-import { ActorConfigZod as ActorConfigZod2 } from "@xyo-network/xl1-sdk";
 
 // src/node/config/locators/actors/apiLocatorFromConfig.ts
 import { ProviderFactoryLocator as ProviderFactoryLocator2, SimpleXyoConnectionRunner, SimpleXyoGateway, SimpleXyoRunner } from "@xyo-network/xl1-sdk";
@@ -1447,19 +1549,16 @@ function apiLocatorFromConfig(context, parent) {
 __name(apiLocatorFromConfig, "apiLocatorFromConfig");
 
 // src/node/config/locators/actors/bridgeLocatorFromConfig.ts
-import { isDefined as isDefined7 } from "@xylabs/sdk-js";
-import { HDWallet as HDWallet4 } from "@xyo-network/sdk-js";
-import { ADDRESS_INDEX as ADDRESS_INDEX2, generateXyoBaseWalletFromPhrase as generateXyoBaseWalletFromPhrase2, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcXyoRunner, JsonRpcXyoViewer, ProviderFactoryLocator as ProviderFactoryLocator3, RestDataLakeRunner, RestDataLakeViewer, SimpleStakeEventsViewer as SimpleStakeEventsViewer2, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2, SimpleXyoGatewayRunner, SimpleXyoRunner as SimpleXyoRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-sdk";
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer3, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcXyoRunner, JsonRpcXyoViewer, ProviderFactoryLocator as ProviderFactoryLocator3, RestDataLakeRunner, RestDataLakeViewer, SimpleStakeEventsViewer as SimpleStakeEventsViewer2, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2, SimpleXyoGatewayRunner, SimpleXyoRunner as SimpleXyoRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-sdk";
 async function bridgeLocatorFromConfig(context, parent) {
   const locator = new ProviderFactoryLocator3({
     ...context,
     locator: parent
   });
   const { config } = context;
-  const { dataLake, mnemonic } = config;
-  const walletPhrase = isDefined7(mnemonic) ? mnemonic : HDWallet4.generateMnemonic();
-  const wallet = await generateXyoBaseWalletFromPhrase2(walletPhrase);
-  const signerAccount = await wallet.derivePath(ADDRESS_INDEX2.XYO);
+  const { dataLake } = config;
+  const signerAccount = await initActorAccount(context);
   if (config.remote.rpc) {
     locator.registerMany([
       JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {}),
@@ -1471,7 +1570,7 @@ async function bridgeLocatorFromConfig(context, parent) {
       JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
     ]);
   }
-  if (isDefined7(dataLake)) {
+  if (isDefined3(dataLake)) {
     const { driver } = dataLake;
     switch (driver) {
       case "rest": {
@@ -1649,7 +1748,7 @@ async function locatorsFromConfig(context, { actors, ...config }) {
       case "validator": {
         result[actorConfig.name] = await validatorLocatorFromConfig({
           ...context,
-          config: ActorConfigZod2.parse(deepMerge2(config, actorConfig))
+          config: ValidatorConfigZod.parse(deepMerge2(config, actorConfig))
         }, result._root);
         break;
       }
@@ -1674,7 +1773,7 @@ async function locatorsFromConfig(context, { actors, ...config }) {
 __name(locatorsFromConfig, "locatorsFromConfig");
 
 // src/node/config/tryParseConfig.ts
-import { isDefined as isDefined8, isNull } from "@xylabs/sdk-js";
+import { isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
 import { ConfigZod } from "@xyo-network/xl1-sdk";
 import { cosmiconfig } from "cosmiconfig";
 var configName = "xyo";
@@ -1686,102 +1785,38 @@ async function tryParseConfig(options) {
     // loaders: { '.ts': TypeScriptLoader() },
     searchPlaces
   });
-  const result = isDefined8(configPath) ? (await explorer.load(configPath))?.config : (await explorer.search())?.config;
-  if (isDefined8(result) && !isNull(result)) {
+  const result = isDefined4(configPath) ? (await explorer.load(configPath))?.config : (await explorer.search())?.config;
+  if (isDefined4(result) && !isNull(result)) {
     const section = result[configSection];
-    if (isDefined8(section) && typeof section === "object") {
-      return ConfigZod.loose().parse(section);
+    if (isDefined4(section) && typeof section === "object") {
+      const parsed = ConfigZod.loose().parse(section);
+      return typeof section.mnemonic === "string" ? {
+        ...parsed,
+        mnemonic: section.mnemonic
+      } : parsed;
     }
   }
   return ConfigZod.parse({});
 }
 __name(tryParseConfig, "tryParseConfig");
 
-// src/node/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/node/sharedMiddleware.ts
-import { customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler, standardResponses } from "@xylabs/express";
-import compression from "compression";
-import cors from "cors";
-function sharedMiddleware(app) {
-  app.set("etag", false);
-  app.use(cors());
-  app.use(compression());
-  app.use(responseProfiler);
-  app.use(getJsonBodyParser(getJsonBodyParserOptions({
-    limit: "1mb"
-  })));
-  app.use(standardResponses);
-  disableExpressDefaultPoweredByHeader(app);
-  app.use(customPoweredByHeader);
-  disableCaseSensitiveRouting(app);
-}
-__name(sharedMiddleware, "sharedMiddleware");
+// src/node/index.ts
+export * from "@xyo-network/chain-orchestration-evm";
+export * from "@xyo-network/chain-orchestration-express";
+export * from "@xyo-network/chain-orchestration-storage";
 export {
   ApiConfigContext,
   ApiConfigZod,
+  BUILT_IN_DEV_MNEMONIC,
   BasisPointsZod,
   BridgeConfigContext,
   BridgeConfigZod,
   BridgeSettingsZod,
+  DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL,
   DefaultServiceProvider,
+  GENESIS_REWARD_AMOUNT,
   GenericHost,
+  INSECURE_GENESIS_REWARD_MNEMONIC,
   MempoolConfigContext,
   MempoolConfigZod,
   NodeManifest,
@@ -1790,8 +1825,10 @@ export {
   ProducerConfigContext,
   ProducerConfigZod,
   PublicChildManifests,
+  ROOT_WALLET_RUNTIME_ID,
   RewardRedemptionConfigContext,
   RewardRedemptionConfigZod,
+  SHARED_ACCOUNT_REPORT_COUNT,
   ServiceLifetime,
   ValidatorActor,
   ValidatorConfigContext,
@@ -1811,36 +1848,28 @@ export {
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
   buildTelemetryConfig,
-  canUseChainId,
-  canUseEvmProvider,
-  canUseInfuraProvider,
-  canUseJsonRpcProvider,
+  clearResolvedWalletReport,
   contextFromConfigWithoutLocator,
   createProducerChainStakeIntentBlock,
-  getChainId,
-  getInfuraProviderConfig,
-  getJsonRpcProviderConfig,
+  formatWalletReport,
+  getBuiltInDevMnemonic,
+  getInsecureGenesisRewardMnemonic,
   getLocator,
+  getReservedActorIndex,
+  getResolvedWalletReport,
   initActorAccount,
   initActorSeedPhrase,
   initActorWallet,
   initBalanceSummaryMap,
   initBridgedArchivistModule,
   initBridgedModule,
-  initChainFinalizedArchivist,
-  initEvmProvider,
   initEvmProvidersIfAvailable,
   initFinalizationArchivistIfNeeded,
   initFinalizedArchivist,
-  initHealthEndpoints,
-  initInfuraProvider,
-  initJsonRpcProvider,
-  initPendingBlocksArchivist,
-  initRejectedTransactionsArchivist,
   initServerNode,
-  initStakeIntentStateArchivist,
   initStatusReporter,
   initTransferSummaryMap,
+  initializeResolvedWalletReport,
   isApiConfig,
   isApiConfigContext,
   isBridgeConfig,
@@ -1857,8 +1886,12 @@ export {
   localLocatorFromConfig,
   locatorsFromConfig,
   mergeConfig,
+  resolveActorWallet,
+  resolveGenesisRewardAddress,
+  resolveRootWallet,
+  resolveWalletForActor,
+  resolveWalletReport,
   rootLocatorFromConfig,
-  sharedMiddleware,
   telemetryContextFromConfig,
   toApiConfig,
   toApiConfigContext,