@xyo-network/chain-orchestration 1.19.13 → 1.19.15

package/dist/neutral/index.mjs

@@ -66,8 +66,8 @@ ValidatorActor = _ts_decorate([
 ], ValidatorActor);
 
 // src/archivists/ChainFinalized/archivist.ts
+import { timeBudget } from "@xylabs/sdk-js";
 import { startupSpanAsync } from "@xyo-network/chain-utils";
-import { timeBudget } from "@xyo-network/xl1-sdk";
 import { Mutex as Mutex2 } from "async-mutex";
 
 // src/archivists/ChainFinalized/local.ts
@@ -101,14 +101,15 @@ var getLocalPersistentArchivist = /* @__PURE__ */ __name((name, dbName, storeNam
 // src/archivists/ChainFinalized/local.ts
 var mutex = new Mutex();
 var singleton;
-var initLocalChainFinalizedArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+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;
   });
-}, "initLocalChainFinalizedArchivist");
+}
+__name(initLocalChainFinalizedArchivist, "initLocalChainFinalizedArchivist");
 
 // src/archivists/ChainFinalized/archivist.ts
 var mutex2 = new Mutex2();
@@ -126,22 +127,23 @@ async function initChainFinalizedArchivist(context) {
 __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 { timeBudget as timeBudget2 } from "@xyo-network/xl1-sdk";
 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;
-var initLocalPendingBlocksArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+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;
   });
-}, "initLocalPendingBlocksArchivist");
+}
+__name(initLocalPendingBlocksArchivist, "initLocalPendingBlocksArchivist");
 
 // src/archivists/PendingBlocks/archivist.ts
 var mutex4 = new Mutex4();
@@ -159,8 +161,8 @@ async function initPendingBlocksArchivist(context) {
 __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 { timeBudget as timeBudget3 } from "@xyo-network/xl1-sdk";
 import { Mutex as Mutex6 } from "async-mutex";
 
 // src/archivists/RejectedTransactions/local.ts
@@ -168,7 +170,7 @@ import { MemoryArchivist, MemoryArchivistConfigSchema } from "@xyo-network/archi
 import { Mutex as Mutex5 } from "async-mutex";
 var mutex5 = new Mutex5();
 var singleton5;
-var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () => {
+async function initLocalRejectedTransactionsArchivist() {
   return await mutex5.runExclusive(async () => {
     if (singleton5) return singleton5;
     singleton5 = await MemoryArchivist.create({
@@ -181,16 +183,17 @@ var initLocalRejectedTransactionsArchivist = /* @__PURE__ */ __name(async () =>
     });
     return singleton5;
   });
-}, "initLocalRejectedTransactionsArchivist");
+}
+__name(initLocalRejectedTransactionsArchivist, "initLocalRejectedTransactionsArchivist");
 
 // src/archivists/RejectedTransactions/archivist.ts
 var mutex6 = new Mutex6();
 var singleton6;
-async function initRejectedTransactionsArchivist(params) {
+async function initRejectedTransactionsArchivist({ logger }) {
   return await mutex6.runExclusive(async () => {
     if (singleton6) return singleton6;
-    return await timeBudget3("initRejectedTransactionsArchivist", params.logger, async () => {
-      const local = await startupSpanAsync3("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist(params));
+    return await timeBudget3("initRejectedTransactionsArchivist", logger, async () => {
+      const local = await startupSpanAsync3("RejectedTransactionsArchivist:initLocal", () => initLocalRejectedTransactionsArchivist());
       singleton6 = local;
       return singleton6;
     }, 2e3, true);
@@ -199,9 +202,8 @@ async function initRejectedTransactionsArchivist(params) {
 __name(initRejectedTransactionsArchivist, "initRejectedTransactionsArchivist");
 
 // src/archivists/StakeIntentState/archivist.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx2, timeBudget as timeBudget4 } from "@xylabs/sdk-js";
 import { startupSpanAsync as startupSpanAsync4 } from "@xyo-network/chain-utils";
-import { timeBudget as timeBudget4 } from "@xyo-network/xl1-sdk";
 import { Mutex as Mutex8 } from "async-mutex";
 
 // src/archivists/StakeIntentState/local.ts
@@ -209,19 +211,20 @@ import { assertEx } from "@xylabs/sdk-js";
 import { Mutex as Mutex7 } from "async-mutex";
 var mutex7 = new Mutex7();
 var singleton7;
-var initLocalStakeIntentStateArchivist = /* @__PURE__ */ __name(async ({ config }) => {
+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"));
   });
-}, "initLocalStakeIntentStateArchivist");
+}
+__name(initLocalStakeIntentStateArchivist, "initLocalStakeIntentStateArchivist");
 
 // src/archivists/StakeIntentState/archivist.ts
 var mutex8 = new Mutex8();
 var singleton8;
-var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
+async function initStakeIntentStateArchivist(context) {
   return await mutex8.runExclusive(async () => {
     if (singleton8) return singleton8;
     return await timeBudget4("initStakeIntentStateArchivist", context.logger, async () => {
@@ -230,7 +233,8 @@ var initStakeIntentStateArchivist = /* @__PURE__ */ __name(async (context) => {
       return assertEx2(singleton8, () => "StakeIntentStateArchivist is undefined");
     }, 2e3, true);
   });
-}, "initStakeIntentStateArchivist");
+}
+__name(initStakeIntentStateArchivist, "initStakeIntentStateArchivist");
 
 // src/buildTelemetryConfig.ts
 function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetricsScrapePort = 9464) {
@@ -251,198 +255,400 @@ function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetric
 }
 __name(buildTelemetryConfig, "buildTelemetryConfig");
 
-// src/createDeclarationIntentBlock.ts
-import { buildNextBlock } from "@xyo-network/chain-sdk";
-import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
-async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
-  const producerDeclarationPayload = createDeclarationIntent(producerAccount.address, "producer", range[0], range[1]);
-  return await buildNextBlock(prevBlock, [], [
-    producerDeclarationPayload
-  ], [
-    producerAccount
-  ]);
-}
-__name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
+// src/config/actors/Api.ts
+import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/zod";
+import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
+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, {
+    description: "Whether to initialize the rewards cache on startup",
+    title: "api.initRewardsCache",
+    type: "boolean"
+  })
+}).shape);
+var isApiConfig = zodIsFactory(ApiConfigZod);
+var asApiConfig = zodAsFactory(ApiConfigZod, "asApiConfig");
+var toApiConfig = zodToFactory(ApiConfigZod, "toApiConfig");
+var ApiConfigContext = BaseConfigContextZod.extend({
+  config: ApiConfigZod
+});
+var isApiConfigContext = zodIsFactory(ApiConfigContext);
+var asApiConfigContext = zodAsFactory(ApiConfigContext, "asApiConfigContext");
+var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
 
-// src/evm/initChainId.ts
-import { assertEx as assertEx3, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
-var canUseChainId = /* @__PURE__ */ __name((config) => {
-  return isDefined(config.evm.chainId);
-}, "canUseChainId");
-var getChainId = /* @__PURE__ */ __name((config) => {
-  const chainId = assertEx3(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/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";
+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_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 BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
+var BridgeConfigZod = HostActorConfigZod2.extend({
+  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+    description: "Address to which bridge escrow will be sent",
+    title: "bridge.escrowAddress",
+    type: "string"
+  }),
+  feesAddress: AddressZod.optional().register(globalRegistry2, {
+    description: "Address to which bridge fees will be sent",
+    title: "bridge.feesAddress",
+    type: "string"
+  }),
+  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry2, {
+    default: DEFAULT_FIXED_FEE,
+    description: "Fixed fee (in AttoXL1) applied to bridge transfers",
+    title: "bridge.feeFixed",
+    type: "bigint"
+  }),
+  feeRateBasisPoints: BasisPointsZod.default(500).register(globalRegistry2, {
+    default: 500,
+    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, {
+    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, {
+    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, {
+    default: "localhost",
+    description: "Host for the Bridge Redis instance",
+    title: "bridge.redisHost",
+    type: "string"
+  }),
+  redisPort: z2.coerce.number().int().positive().default(6379).register(globalRegistry2, {
+    default: 6379,
+    description: "Port for the Bridge Redis instance",
+    title: "bridge.redisPort",
+    type: "number"
+  }),
+  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
+    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, {
+    default: DEFAULT_HARDHAT_CHAIN_ID,
+    description: "Remote chain ID",
+    title: "bridge.remoteChainId",
+    type: "string"
+  }),
+  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
+    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, {
+    description: "Private key for the wallet to use for the remote chain wallet",
+    title: "bridge.remoteChainWalletPrivateKey",
+    type: "string"
+  }),
+  xl1ChainId: HexZod.optional().register(globalRegistry2, {
+    description: "XL1 chain id used for bridging",
+    title: "bridge.xl1ChainId",
+    type: "string"
+  }),
+  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
+    description: "XL1 token address used for bridging",
+    title: "bridge.xl1TokenAddress",
+    type: "string"
+  })
+});
+var BridgeSettingsZod = BridgeConfigZod.pick({
+  feeFixed: true,
+  feeRateBasisPoints: true,
+  feesAddress: true,
+  escrowAddress: true,
+  maxBridgeAmount: true,
+  minBridgeAmount: true,
+  remoteChainId: true,
+  remoteTokenAddress: true,
+  xl1TokenAddress: true,
+  xl1ChainId: true
+}).required();
+var isBridgeConfig = zodIsFactory2(BridgeConfigZod);
+var asBridgeConfig = zodAsFactory2(BridgeConfigZod, "asBridgeConfig");
+var toBridgeConfig = zodToFactory2(BridgeConfigZod, "toBridgeConfig");
+var BridgeConfigContext = BaseConfigContextZod2.extend({
+  config: BridgeConfigZod
+});
+var isBridgeConfigContext = zodIsFactory2(BridgeConfigContext);
+var asBridgeConfigContext = zodAsFactory2(BridgeConfigContext, "asBridgeConfigContext");
+var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigContext");
 
-// src/evm/initEvmProvider.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+// src/config/actors/Mempool.ts
+import { zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/zod";
+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({
+  enabled: z3.union([
+    z3.string(),
+    z3.boolean()
+  ]).default("false").transform((val, ctx) => {
+    if (typeof val === "boolean") return val;
+    const normalized = val.toLowerCase().trim();
+    if ([
+      "true",
+      "1",
+      "yes",
+      "on"
+    ].includes(normalized)) return true;
+    if ([
+      "false",
+      "0",
+      "no",
+      "off"
+    ].includes(normalized)) return false;
+    ctx.addIssue({
+      code: "invalid_type",
+      expected: "boolean",
+      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
+    });
+    return z3.NEVER;
+  }).register(globalRegistry3, {
+    default: "false",
+    description: "Enable the Mempool",
+    title: "mempool.enabled",
+    type: "boolean"
+  })
+});
+var isMempoolConfig = zodIsFactory3(MempoolConfigZod);
+var asMempoolConfig = zodAsFactory3(MempoolConfigZod, "asMempoolConfig");
+var toMempoolConfig = zodToFactory3(MempoolConfigZod, "toMempoolConfig");
+var MempoolConfigContext = BaseConfigContextZod3.extend({
+  config: MempoolConfigZod
+});
+var isMempoolConfigContext = zodIsFactory3(MempoolConfigContext);
+var asMempoolConfigContext = zodAsFactory3(MempoolConfigContext, "asMempoolConfigContext");
+var toMempoolConfigContext = zodToFactory3(MempoolConfigContext, "toMempoolConfigContext");
 
-// src/evm/initInfuraProvider.ts
-import { assertEx as assertEx4, isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { InfuraProvider } from "ethers/providers";
-var instance;
-var initInfuraProvider = /* @__PURE__ */ __name((config) => {
-  if (instance) return instance;
-  const providerConfig = getInfuraProviderConfig(config);
-  instance = Promise.resolve(new InfuraProvider(providerConfig[0], providerConfig[1]));
-  return instance;
-}, "initInfuraProvider");
-var canUseInfuraProvider = /* @__PURE__ */ __name((config) => {
-  return canUseChainId(config) && isDefined2(config.evm?.infura?.projectId) && isDefined2(config.evm?.infura?.projectSecret);
-}, "canUseInfuraProvider");
-var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
-  const projectId = assertEx4(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx4(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
-  return [
-    getChainId(config),
-    projectId,
-    projectSecret
-  ];
-}, "getInfuraProviderConfig");
+// 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";
+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) => {
+    if (typeof val === "string") {
+      return val.split(",").map((s) => asAddress(s.trim()));
+    }
+    return val;
+  }, z4.array(AddressZod2).optional().register(globalRegistry4, {
+    description: "List of allowed producer addresses, if undefined anyone can participate",
+    title: "allowlist",
+    type: "array"
+  })),
+  disableIntentRedeclaration: z4.boolean().optional().register(globalRegistry4, {
+    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, {
+    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, {
+    description: "Minimum stake required to be a Producer",
+    title: "producer.minStake",
+    type: "number"
+  }),
+  // TODO: Address schema
+  rewardAddress: z4.string().optional().register(globalRegistry4, {
+    description: "Address to receive block rewards",
+    title: "producer.rewardAddress",
+    type: "string"
+  })
+}).shape);
+var isProducerConfig = zodIsFactory4(ProducerConfigZod);
+var asProducerConfig = zodAsFactory4(ProducerConfigZod, "asProducerConfig");
+var toProducerConfig = zodToFactory4(ProducerConfigZod, "toProducerConfig");
+var ProducerConfigContext = BaseConfigContextZod4.extend({
+  config: ProducerConfigZod
+});
+var isProducerConfigContext = zodIsFactory4(ProducerConfigContext);
+var asProducerConfigContext = zodAsFactory4(ProducerConfigContext, "asProducerConfigContext");
+var toProducerConfigContext = zodToFactory4(ProducerConfigContext, "toProducerConfigContext");
 
-// src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx5, isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { JsonRpcProvider } from "ethers/providers";
-var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
-  const providerConfig = getJsonRpcProviderConfig(config);
-  return Promise.resolve(new JsonRpcProvider(...providerConfig));
-}, "initJsonRpcProvider");
-var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
-  return canUseChainId(config) && isDefined3(config.evm.jsonRpc?.url);
-}, "canUseJsonRpcProvider");
-var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx5(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
-  return [
-    jsonRpcUrl,
-    getChainId(config)
-  ];
-}, "getJsonRpcProviderConfig");
+// src/config/actors/RewardRedemption.ts
+import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/zod";
+import { BaseConfigContextZod as BaseConfigContextZod5, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
+var RewardRedemptionConfigZod = HostActorConfigZod4.extend({});
+var isRewardRedemptionConfig = zodIsFactory5(RewardRedemptionConfigZod);
+var asRewardRedemptionConfig = zodAsFactory5(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
+var toRewardRedemptionConfig = zodToFactory5(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
+var RewardRedemptionConfigContext = BaseConfigContextZod5.extend({
+  config: RewardRedemptionConfigZod
+});
+var isRewardRedemptionConfigContext = zodIsFactory5(RewardRedemptionConfigContext);
+var asRewardRedemptionConfigContext = zodAsFactory5(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
+var toRewardRedemptionConfigContext = zodToFactory5(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
 
-// src/evm/initEvmProvider.ts
-var provider;
-var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
-  if (provider) return provider;
-  if (canUseInfuraProvider(config)) {
-    provider = initInfuraProvider(config);
-  } else if (canUseJsonRpcProvider(config)) {
-    provider = initJsonRpcProvider(config);
-  }
-  return assertEx6(await provider, () => "No provider available");
-}, "initEvmProvider");
-var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
-  return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
-}, "canUseEvmProvider");
-
-// src/health/initHealthEndpoints.ts
-import http from "http";
-import { isDefined as isDefined4 } from "@xylabs/sdk-js";
-var sendStatus = /* @__PURE__ */ __name((res, status, errorCode) => {
-  const statusCode = status === "started" ? 200 : errorCode;
-  res.writeHead(statusCode, {
-    "Content-Type": "application/json"
-  });
-  res.end(JSON.stringify({
-    status
-  }));
-}, "sendStatus");
-var notFound = /* @__PURE__ */ __name((res) => {
-  res.writeHead(404, {
-    "Content-Type": "application/json"
+// 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
   });
-  res.end(JSON.stringify({
-    status: "not found"
-  }));
-}, "notFound");
-var createHealthServer = /* @__PURE__ */ __name((port, statusMonitor, logger) => {
-  const server = http.createServer((req, res) => {
-    const url = req.url ?? "";
-    const status = statusMonitor.getGlobalStatus();
-    switch (url) {
-      case "/healthz": {
-        sendStatus(res, status, 500);
-        break;
-      }
-      case "/livez": {
-        sendStatus(res, status, 503);
-        break;
-      }
-      case "/readyz": {
-        sendStatus(res, status, 503);
-        break;
-      }
-      default: {
-        notFound(res);
-      }
-    }
+  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, MempoolRunnerRpcSchemas, MempoolViewerRpcSchemas, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2, SimpleXyoGatewayRunner, SimpleXyoRunner as SimpleXyoRunner2, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
+async function bridgeLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator2({
+    ...context,
+    locator: parent
   });
-  server.listen(port, () => {
-    logger.log(`Health server running on http://localhost:${port}`);
-    logger.log(" - /healthz");
-    logger.log(" - /livez");
-    logger.log(" - /readyz");
+  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)
+      })
+    ]);
+  }
+  locator.registerMany([
+    SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
+      account: signerAccount
+    }),
+    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
   });
-  return server;
-}, "createHealthServer");
-var initHealthEndpoints = /* @__PURE__ */ __name((params) => {
-  const { config, logger, statusReporter } = params;
-  const { healthCheckPort } = config.actors.producer;
-  return isDefined4(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : void 0;
-}, "initHealthEndpoints");
+  locator.registerMany([
+    SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {})
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(mempoolLocatorFromConfig, "mempoolLocatorFromConfig");
 
-// src/host/implementation/DefaultHost.ts
-var GenericHost = class {
-  static {
-    __name(this, "GenericHost");
-  }
-  services;
-  constructor(services) {
-    this.services = services;
-  }
-  async start() {
-    await Promise.resolve();
-    console.log("Host is starting...");
-  }
-  async stop() {
-    await Promise.resolve();
-    console.log("Host is stopping...");
-  }
-};
+// src/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";
 
-// src/host/implementation/DefaultServiceProvider.ts
-var DefaultServiceProvider = class {
-  static {
-    __name(this, "DefaultServiceProvider");
-  }
-  _services;
-  constructor(services) {
-    this._services = services;
-  }
-  getService(serviceIdentifier) {
-    return this._services[serviceIdentifier];
+// src/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";
+var actorAccountSingletons = {};
+async function initActorAccount({ config, logger }) {
+  const actorName = config.name;
+  if (isDefined2(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
+  let walletPhrase = config.mnemonic;
+  if (isUndefined(walletPhrase)) {
+    logger?.warn(`[${actorName}}] No wallet mnemonic specified!`);
+    const randomMnemonic = HDWallet2.generateMnemonic();
+    logger?.warn(`[${actorName}}] Using randomly generated mnemonic:
+    
+${randomMnemonic}
+      
+    `);
+    walletPhrase = randomMnemonic;
   }
-};
+  const wallet = await generateXyoBaseWalletFromPhrase2(walletPhrase);
+  const account = await wallet.derivePath(ADDRESS_INDEX2.XYO);
+  actorAccountSingletons[actorName] = account;
+  return actorAccountSingletons[actorName];
+}
+__name(initActorAccount, "initActorAccount");
 
-// src/host/model/ServiceCollection.ts
-var ServiceLifetime = {
-  Singleton: "Singleton",
-  Transient: "Transient"
-};
+// src/init/initActorSeedPhrase.ts
+import { assertEx as assertEx3, isString as isString2 } from "@xylabs/sdk-js";
+import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
+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)) {
+    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)) {
+      seedPhrase = mnemonic;
+    } else {
+      seedPhrase = HDWallet3.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");
+}
+__name(initActorSeedPhrase, "initActorSeedPhrase");
 
 // src/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+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({ config, logger }) {
+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;
@@ -464,7 +670,7 @@ async function initBalanceSummaryMap({ config, logger }) {
         maxEntries: 5e3
       }
     });
-    assertEx7(await result.start(), () => "Failed to start transfer summary map");
+    assertEx4(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -474,18 +680,18 @@ async function initBalanceSummaryMap({ config, logger }) {
 __name(initBalanceSummaryMap, "initBalanceSummaryMap");
 
 // src/init/initBridgedModule.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance } from "@xyo-network/archivist-model";
 import { asAttachableModuleInstance } from "@xyo-network/module-model";
 import { Mutex as Mutex9 } from "async-mutex";
 var initMutex = new Mutex9();
 var bridgedModuleDictionary = {};
-var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
+async function initBridgedModule({ bridge, moduleName }) {
   return await initMutex.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
-    const mod = assertEx8(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx8(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    const mod = assertEx5(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx5(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
     let moduleMap = bridgedModuleDictionary[bridge.address];
     if (moduleMap === void 0) {
       moduleMap = {};
@@ -494,28 +700,110 @@ var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) =>
     moduleMap[moduleName] = moduleInstance;
     return moduleInstance;
   });
-}, "initBridgedModule");
-var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return assertEx8(asAttachableArchivistInstance(await initBridgedModule({
+}
+__name(initBridgedModule, "initBridgedModule");
+async function initBridgedArchivistModule({ bridge, moduleName }) {
+  return assertEx5(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
-}, "initBridgedArchivistModule");
+}
+__name(initBridgedArchivistModule, "initBridgedArchivistModule");
 
 // src/init/initEvmProvidersIfAvailable.ts
-import { asEthAddress, assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { asEthAddress, assertEx as assertEx10 } from "@xylabs/sdk-js";
 import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
 import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
-async function initEvmProvidersIfAvailable(locator) {
-  const { config, logger } = locator.context;
-  if (canUseEvmProvider({
-    config
+
+// src/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 chainId = assertEx9(config.chain.id, () => "Missing config.chain.chainId (required for EVM providers)");
-    const provider2 = await initEvmProvider({
-      config,
-      logger
-    });
+    const hex = hexFrom(chainId);
+    const parsed = Number.parseInt(hex, 16);
+    return parsed;
+  } else {
+    const parsed = Number.parseInt(chainId, 10);
+    return parsed;
+  }
+}, "getChainId");
+
+// src/evm/initEvmProvider.ts
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+
+// src/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/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/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/init/initEvmProvidersIfAvailable.ts
+async function initEvmProvidersIfAvailable(locator) {
+  const context = locator.context;
+  const { logger, config } = context;
+  if (canUseEvmProvider(context)) {
+    const chainId = assertEx10(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, {
       address,
@@ -539,7 +827,7 @@ async function initEvmProvidersIfAvailable(locator) {
   } else {
     logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
     const positions = [];
-    const chainId = assertEx9(config.chain.id, () => "Missing config.chain.chainId (required for non-EVM providers)");
+    const chainId = assertEx10(config.chain.id, () => "Missing config.chain.id (required for non-EVM providers)");
     locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {
       positions
     }));
@@ -560,9 +848,9 @@ async function initEvmProvidersIfAvailable(locator) {
 __name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
 // src/init/initFinalizationArchivistIfNeeded.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
-import { Account } from "@xyo-network/account";
+import { 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;
@@ -577,8 +865,8 @@ async function initFinalizationArchivistIfNeeded(archivist, config, account) {
     const payloads = chain.flatMap((block) => flattenHydratedBlock(block));
     await archivist.insert(payloads);
   }
-  const head = possibleHead ?? assertEx10(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
-  const chainId = assertEx10(possibleChainId, () => "Chain ID could not be determined");
+  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
@@ -604,61 +892,12 @@ async function initFinalizedArchivist(config) {
 }
 __name(initFinalizedArchivist, "initFinalizedArchivist");
 
-// src/init/initProducerAccount.ts
-import { isUndefined } from "@xylabs/sdk-js";
-import { HDWallet } from "@xyo-network/wallet";
-import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
-var accountServiceSingleton;
-var initProducerAccount = /* @__PURE__ */ __name(async ({ config, logger }) => {
-  if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config.actors.producer.mnemonic;
-  if (isUndefined(walletPhrase)) {
-    logger?.warn("[Producer] No wallet mnemonic specified!");
-    const randomMnemonic = HDWallet.generateMnemonic();
-    logger?.warn(`[Producer] Using randomly generated mnemonic:
-    
-${randomMnemonic}
-      
-    `);
-    walletPhrase = randomMnemonic;
-  }
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
-  accountServiceSingleton = account;
-  return accountServiceSingleton;
-}, "initProducerAccount");
-
-// src/init/initSeedPhrase.ts
-import { assertEx as assertEx11, isString } from "@xylabs/sdk-js";
-import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
-async function initSeedPhrase({ config, logger, bios }) {
-  const storedSeedPhrase = await bios.seedPhraseStore.get("os");
-  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`);
-  const { mnemonic } = config.actors.api;
-  if (isString(storedSeedPhrase) && isString(mnemonic)) {
-    logger?.warn("[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.");
-    await bios.seedPhraseStore.set("os", mnemonic);
-  } 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("os", seedPhrase);
-  }
-  return assertEx11(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
-}
-__name(initSeedPhrase, "initSeedPhrase");
-
 // src/init/initServerNode.ts
 import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 
 // src/manifest/getLocator.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+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";
@@ -667,7 +906,7 @@ import { AbstractModule, LoggerModuleStatusReporter } from "@xyo-network/module-
 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 ({ config, logger }) => {
+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({
@@ -681,7 +920,7 @@ var getLocator = /* @__PURE__ */ __name(async ({ config, logger }) => {
       port
     }
   });
-  if (isDefined5(logger)) AbstractModule.defaultLogger = logger;
+  if (isDefined6(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
@@ -867,12 +1106,8 @@ var PublicChildManifests = [
 ];
 
 // src/manifest/loadNode.ts
-var loadNode = /* @__PURE__ */ __name(async ({ wallet, config, balancesSummaryMap, transfersSummaryMap }) => {
-  const locator = await getLocator({
-    config,
-    balancesSummaryMap,
-    transfersSummaryMap
-  });
+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) {
@@ -907,14 +1142,8 @@ async function pendingBlocksArchivistFromNode(node) {
   });
 }
 __name(pendingBlocksArchivistFromNode, "pendingBlocksArchivistFromNode");
-async function initServerNode({ wallet, logger, config, node: providedNode, transfersSummaryMap, balancesSummaryMap }) {
-  const node = providedNode ?? await loadNode({
-    wallet,
-    logger,
-    config,
-    transfersSummaryMap,
-    balancesSummaryMap
-  });
+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);
@@ -954,7 +1183,7 @@ 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({ config, logger }) {
+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;
@@ -986,67 +1215,463 @@ async function initTransferSummaryMap({ config, logger }) {
 __name(initTransferSummaryMap, "initTransferSummaryMap");
 
 // src/init/initWallet.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { isDefined as isDefined7 } from "@xylabs/sdk-js";
 import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
-async function initWallet({ config, logger }, mnemonic) {
+import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
+async function initActorWallet(context, mnemonic) {
   const bios = await boot();
-  const seedPhrase = isDefined6(mnemonic) ? mnemonic : await initSeedPhrase({
-    bios,
-    config,
-    logger
+  const seedPhrase = isDefined7(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
+  return await HDWallet4.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
   });
-  return await HDWallet3.fromPhrase(seedPhrase);
+  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(initWallet, "initWallet");
-async function initApiWallet({ config, logger }) {
-  const { mnemonic } = config.actors.api;
-  return await initWallet({
-    config,
-    logger
-  }, mnemonic);
+__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(initApiWallet, "initApiWallet");
-async function initBridgeWallet({ config, logger }) {
-  const { mnemonic } = config.actors.bridge;
-  return await initWallet({
-    config,
-    logger
-  }, mnemonic);
+__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(initBridgeWallet, "initBridgeWallet");
-async function initMempoolWallet({ config, logger }) {
-  const { mnemonic } = config.actors.mempool;
-  return await initWallet({
-    config,
-    logger
-  }, mnemonic);
+__name(validatorLocatorFromConfig, "validatorLocatorFromConfig");
+
+// src/config/locators/telemetryContextFromConfig.ts
+import { initTelemetry as initTelemetry2 } 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({
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  });
 }
-__name(initMempoolWallet, "initMempoolWallet");
-async function initProducerWallet({ config, logger }) {
-  const { mnemonic } = config.actors.producer;
-  return await initWallet({
-    config,
+__name(telemetryContextFromConfig, "telemetryContextFromConfig");
+
+// src/config/locators/contextFromConfigWithoutLocator.ts
+async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion) {
+  const singletons = {};
+  const caches = {};
+  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion);
+  const statusReporter = initStatusReporter({
     logger
-  }, mnemonic);
-}
-__name(initProducerWallet, "initProducerWallet");
-async function initRewardsRedemptionApiWallet({ config, logger }) {
-  const { mnemonic } = config.actors.rewardRedemption;
-  return await initWallet({
+  });
+  return {
+    ...telemetryConfig,
     config,
-    logger
-  }, mnemonic);
+    singletons,
+    caches,
+    logger,
+    statusReporter
+  };
 }
-__name(initRewardsRedemptionApiWallet, "initRewardsRedemptionApiWallet");
-async function initValidatorWallet({ config, logger }) {
-  const { mnemonic } = config.actors.mempool;
-  return await initWallet({
-    config,
-    logger
-  }, mnemonic);
+__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);
+  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
+    })
+  ]);
+  locator.freeze();
+  return locator;
+}
+__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 } from "@xyo-network/xl1-sdk";
+
+// src/config/locators/remoteLocatorFromConfig.ts
+import { assertEx as assertEx15 } from "@xylabs/sdk-js";
+import { ProviderFactoryLocator as ProviderFactoryLocator8, SimpleAccountBalanceViewer as SimpleAccountBalanceViewer2, SimpleBlockViewer as SimpleBlockViewer2, SimpleFinalizationViewer as SimpleFinalizationViewer2, SimpleMempoolRunner as SimpleMempoolRunner2, SimpleMempoolViewer as SimpleMempoolViewer2, SimpleWindowedBlockViewer as SimpleWindowedBlockViewer2, SimpleXyoViewer as SimpleXyoViewer2 } from "@xyo-network/xl1-sdk";
+async function remoteLocatorFromConfig(context, parent) {
+  const balancesSummaryMap = assertEx15(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
+  const transfersSummaryMap = assertEx15(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
+  const wallet = await initActorWallet(context);
+  const { readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist } = await initServerNode(context, wallet);
+  const locator = new ProviderFactoryLocator8({
+    ...context,
+    locator: parent
+  });
+  locator.registerMany([
+    SimpleMempoolViewer2.factory(SimpleMempoolViewer2.dependencies, {
+      pendingTransactionsArchivist,
+      pendingBlocksArchivist
+    }),
+    SimpleMempoolRunner2.factory(SimpleMempoolRunner2.dependencies, {
+      pendingTransactionsArchivist,
+      pendingBlocksArchivist
+    }),
+    SimpleAccountBalanceViewer2.factory(SimpleAccountBalanceViewer2.dependencies, {
+      balancesSummaryMap,
+      transfersSummaryMap
+    }),
+    SimpleFinalizationViewer2.factory(SimpleFinalizationViewer2.dependencies, {
+      finalizedArchivist: readonlyChainArchivist
+    }),
+    SimpleBlockViewer2.factory(SimpleBlockViewer2.dependencies, {
+      finalizedArchivist: readonlyChainArchivist
+    }),
+    SimpleWindowedBlockViewer2.factory(SimpleWindowedBlockViewer2.dependencies, {
+      maxWindowSize: 1e4,
+      syncInterval: 1e4
+    }),
+    SimpleXyoViewer2.factory(SimpleXyoViewer2.dependencies, {
+      finalizedArchivist: readonlyChainArchivist
+    })
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(remoteLocatorFromConfig, "remoteLocatorFromConfig");
+
+// src/config/locators/rootLocatorFromConfig.ts
+async function rootLocatorFromConfig(context) {
+  const { config } = context;
+  let locator = new ProviderFactoryLocator9(context);
+  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
+    })
+  ]);
+  locator = await initEvmProvidersIfAvailable(locator);
+  locator = await (isString4(config.remote.rpc?.url) ? remoteLocatorFromConfig(context, locator) : localLocatorFromConfig(context, locator));
+  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");
+
+// src/config/mergeConfig.ts
+import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
+function mergeConfig({ actors, ...baseConfig }) {
+  return {
+    ...baseConfig,
+    actors: actors.map((actor) => {
+      return deepMerge2(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 (!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
+import { buildNextBlock } from "@xyo-network/chain-sdk";
+import { createDeclarationIntent } from "@xyo-network/xl1-sdk";
+async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, range) {
+  const producerDeclarationPayload = createDeclarationIntent(producerAccount.address, "producer", range[0], range[1]);
+  return await buildNextBlock(prevBlock, [], [
+    producerDeclarationPayload
+  ], [
+    producerAccount
+  ]);
+}
+__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(initValidatorWallet, "initValidatorWallet");
+__name(initHealthEndpoints, "initHealthEndpoints");
+
+// src/host/implementation/DefaultHost.ts
+var GenericHost = class {
+  static {
+    __name(this, "GenericHost");
+  }
+  services;
+  constructor(services) {
+    this.services = services;
+  }
+  async start() {
+    await Promise.resolve();
+    console.log("Host is starting...");
+  }
+  async stop() {
+    await Promise.resolve();
+    console.log("Host is stopping...");
+  }
+};
+
+// src/host/implementation/DefaultServiceProvider.ts
+var DefaultServiceProvider = class {
+  static {
+    __name(this, "DefaultServiceProvider");
+  }
+  _services;
+  constructor(services) {
+    this._services = services;
+  }
+  getService(serviceIdentifier) {
+    return this._services[serviceIdentifier];
+  }
+};
+
+// src/host/model/ServiceCollection.ts
+var ServiceLifetime = {
+  Singleton: "Singleton",
+  Transient: "Transient"
+};
 
 // src/orchestrator/Orchestrator.ts
 import { AbstractCreatable, creatable as creatable2 } from "@xylabs/sdk-js";
@@ -1113,27 +1738,53 @@ Orchestrator = _ts_decorate2([
   creatable2()
 ], Orchestrator);
 export {
+  ApiConfigContext,
+  ApiConfigZod,
+  BasisPointsZod,
+  BridgeConfigContext,
+  BridgeConfigZod,
+  BridgeSettingsZod,
   DefaultServiceProvider,
   GenericHost,
+  MempoolConfigContext,
+  MempoolConfigZod,
   NodeManifest,
   Orchestrator,
   PrivateChildManifests,
+  ProducerConfigContext,
+  ProducerConfigZod,
   PublicChildManifests,
+  RewardRedemptionConfigContext,
+  RewardRedemptionConfigZod,
   ServiceLifetime,
   ValidatorActor,
+  apiLocatorFromConfig,
+  asApiConfig,
+  asApiConfigContext,
+  asBridgeConfig,
+  asBridgeConfigContext,
+  asMempoolConfig,
+  asMempoolConfigContext,
+  asProducerConfig,
+  asProducerConfigContext,
+  asRewardRedemptionConfig,
+  asRewardRedemptionConfigContext,
+  bridgeLocatorFromConfig,
   buildTelemetryConfig,
   canUseChainId,
   canUseEvmProvider,
   canUseInfuraProvider,
   canUseJsonRpcProvider,
+  contextFromConfigWithoutLocator,
   createProducerChainStakeIntentBlock,
   getChainId,
   getInfuraProviderConfig,
   getJsonRpcProviderConfig,
   getLocator,
-  initApiWallet,
+  initActorAccount,
+  initActorSeedPhrase,
+  initActorWallet,
   initBalanceSummaryMap,
-  initBridgeWallet,
   initBridgedArchivistModule,
   initBridgedModule,
   initChainFinalizedArchivist,
@@ -1144,18 +1795,43 @@ export {
   initHealthEndpoints,
   initInfuraProvider,
   initJsonRpcProvider,
-  initMempoolWallet,
   initPendingBlocksArchivist,
-  initProducerAccount,
-  initProducerWallet,
   initRejectedTransactionsArchivist,
-  initRewardsRedemptionApiWallet,
-  initSeedPhrase,
   initServerNode,
   initStakeIntentStateArchivist,
   initStatusReporter,
   initTransferSummaryMap,
-  initValidatorWallet,
-  loadNode
+  isApiConfig,
+  isApiConfigContext,
+  isBridgeConfig,
+  isBridgeConfigContext,
+  isMempoolConfig,
+  isMempoolConfigContext,
+  isProducerConfig,
+  isProducerConfigContext,
+  isRewardRedemptionConfig,
+  isRewardRedemptionConfigContext,
+  loadNode,
+  localLocatorFromConfig,
+  locatorsFromConfig,
+  mempoolLocatorFromConfig,
+  mergeConfig,
+  producerLocatorFromConfig,
+  remoteLocatorFromConfig,
+  rewardRedemptionLocatorFromConfig,
+  rootLocatorFromConfig,
+  telemetryContextFromConfig,
+  toApiConfig,
+  toApiConfigContext,
+  toBridgeConfig,
+  toBridgeConfigContext,
+  toMempoolConfig,
+  toMempoolConfigContext,
+  toProducerConfig,
+  toProducerConfigContext,
+  toRewardRedemptionConfig,
+  toRewardRedemptionConfigContext,
+  tryParseConfig,
+  validatorLocatorFromConfig
 };
 //# sourceMappingURL=index.mjs.map