@xyo-network/chain-orchestration 1.19.18 → 1.20.0

package/dist/node/index.mjs

@@ -0,0 +1,1889 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/shared/actor/ValidatorActor.ts
+import { creatable } from "@xylabs/sdk-js";
+import { processPendingBlocks } from "@xyo-network/chain-sdk";
+import { ActorV3, BlockViewerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var ValidatorActor = class extends ActorV3 {
+  static {
+    __name(this, "ValidatorActor");
+  }
+  _blockViewer;
+  _finalizationRunner;
+  _lastValidatedBlock;
+  _lastValidatedBlockHash;
+  _mempoolViewer;
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  get finalizationRunner() {
+    return this._finalizationRunner;
+  }
+  get mempoolViewer() {
+    return this._mempoolViewer;
+  }
+  async createHandler() {
+    await super.startHandler();
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+    this._finalizationRunner = await this.locator.getInstance(FinalizationRunnerMoniker);
+    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker);
+  }
+  async startHandler() {
+    await super.startHandler();
+    this.registerTimer(
+      "ValidatorActor",
+      async () => {
+        await this.spanAsync("processPendingBlocks", async () => {
+          console.log("ValidatorActor: Processing pending blocks...");
+          await processPendingBlocks({
+            context: this.context,
+            logger: this.logger,
+            mempoolViewer: this.mempoolViewer,
+            blockViewer: this.blockViewer,
+            finalizationRunner: this.finalizationRunner
+          });
+        }, {
+          ...this.context,
+          timeBudgetLimit: 1500
+        });
+      },
+      2e3,
+      1500
+      /* 500 */
+    );
+  }
+};
+ValidatorActor = _ts_decorate([
+  creatable()
+], ValidatorActor);
+
+// src/shared/buildTelemetryConfig.ts
+function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetricsScrapePort = 9464) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = defaultMetricsScrapePort } = config.telemetry?.metrics?.scrape ?? {};
+  const telemetryConfig = {
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  };
+  return telemetryConfig;
+}
+__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, 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/shared/config/actors/Bridge.ts
+import { AddressZod, HexZod, toAddress, toHex, zodAsFactory as zodAsFactory2, zodIsFactory as zodIsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/sdk-js";
+import { AttoXL1ConvertFactor, BaseConfigContextZod as BaseConfigContextZod2, HostActorConfigZod as HostActorConfigZod2, XL1 } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
+var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
+var DEFAULT_HARDHAT_CHAIN_ID = toHex("7A69");
+var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f64180aa3");
+var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(100000000n) * AttoXL1ConvertFactor.xl1);
+var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
+var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
+var BridgeConfigZod = HostActorConfigZod2.extend({
+  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+    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(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+    default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
+    description: "Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers",
+    title: "bridge.feeRateBasisPoints",
+    type: "number"
+  }),
+  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/shared/config/actors/Mempool.ts
+import { zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/sdk-js";
+import { BaseConfigContextZod as BaseConfigContextZod3, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+var MempoolConfigZod = HostActorConfigZod3.extend({
+  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/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) => {
+    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/shared/config/actors/RewardRedemption.ts
+import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/sdk-js";
+import { BaseConfigContextZod as BaseConfigContextZod5, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
+var RewardRedemptionConfigZod = HostActorConfigZod4.extend({});
+var isRewardRedemptionConfig = zodIsFactory5(RewardRedemptionConfigZod);
+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/shared/config/locators/commonLocatorFromConfig.ts
+import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
+import { ProviderFactoryLocator, SimpleBlockRewardViewer, SimpleBlockValidationViewer, SimpleNetworkStakeViewer, SimpleStepRewardsByPositionViewer, SimpleStepRewardsByStakerViewer, SimpleStepRewardsByStepViewer, SimpleStepRewardsTotalViewer, SimpleStepRewardsViewer, SimpleStepViewer, SimpleTimeSyncViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer } from "@xyo-network/xl1-sdk";
+function commonLocatorFromConfig(context, validateDepsOnRegister = false) {
+  let locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister);
+  locator.registerMany([
+    SimpleNetworkStakeViewer.factory(SimpleNetworkStakeViewer.dependencies, {}),
+    SimpleTimeSyncViewer.factory(SimpleTimeSyncViewer.dependencies, {}),
+    SimpleStepViewer.factory(SimpleStepViewer.dependencies, {}),
+    SimpleStepRewardsViewer.factory(SimpleStepRewardsViewer.dependencies, {}),
+    SimpleStepRewardsByPositionViewer.factory(SimpleStepRewardsByPositionViewer.dependencies, {}),
+    SimpleStepRewardsByStakerViewer.factory(SimpleStepRewardsByStakerViewer.dependencies, {}),
+    SimpleStepRewardsByStepViewer.factory(SimpleStepRewardsByStepViewer.dependencies, {}),
+    SimpleStepRewardsTotalViewer.factory(SimpleStepRewardsTotalViewer.dependencies, {}),
+    SimpleWindowedBlockViewer.factory(SimpleWindowedBlockViewer.dependencies, {
+      maxWindowSize: 1e4,
+      syncInterval: 1e4
+    }),
+    SimpleBlockRewardViewer.factory(SimpleBlockRewardViewer.dependencies, {}),
+    SimpleBlockValidationViewer.factory(SimpleBlockValidationViewer.dependencies, {
+      state: validateHydratedBlockState,
+      protocol: validateHydratedBlock
+    }),
+    SimpleTransactionViewer.factory(SimpleTransactionViewer.dependencies, {})
+  ]);
+  return locator;
+}
+__name(commonLocatorFromConfig, "commonLocatorFromConfig");
+
+// src/shared/init/initActorAccount.ts
+import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { HDWallet } from "@xyo-network/sdk-js";
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+var actorAccountSingletons = {};
+async function initActorAccount({ config, logger }) {
+  const actorName = config.name;
+  if (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);
+  actorAccountSingletons[actorName] = account;
+  return actorAccountSingletons[actorName];
+}
+__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");
+}
+__name(initActorSeedPhrase, "initActorSeedPhrase");
+
+// src/shared/init/initBridgedModule.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { asAttachableArchivistInstance, asAttachableModuleInstance } from "@xyo-network/sdk-js";
+import { Mutex } from "async-mutex";
+var initMutex = new Mutex();
+var bridgedModuleDictionary = {};
+async function initBridgedModule({ bridge, moduleName }) {
+  return await initMutex.runExclusive(async () => {
+    const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
+    if (existing) return existing;
+    const mod = assertEx2(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx2(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    let moduleMap = bridgedModuleDictionary[bridge.address];
+    if (moduleMap === void 0) {
+      moduleMap = {};
+      bridgedModuleDictionary[bridge.address] = moduleMap;
+    }
+    moduleMap[moduleName] = moduleInstance;
+    return moduleInstance;
+  });
+}
+__name(initBridgedModule, "initBridgedModule");
+async function initBridgedArchivistModule({ bridge, moduleName }) {
+  return assertEx2(asAttachableArchivistInstance(await initBridgedModule({
+    bridge,
+    moduleName
+  })), () => `Could not convert ${moduleName} to attachable archivist instance`);
+}
+__name(initBridgedArchivistModule, "initBridgedArchivistModule");
+
+// src/shared/init/initEvmProvidersIfAvailable.ts
+import { asEthAddress, assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer } from "@xyo-network/chain-ethereum";
+import { SimpleChainContractViewer, SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer as SimpleTimeSyncViewer2, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-sdk";
+
+// src/shared/evm/initChainId.ts
+import { assertEx as assertEx3, hexFrom, isDefined as isDefined2, isHex } from "@xylabs/sdk-js";
+var canUseChainId = /* @__PURE__ */ __name(({ config }) => {
+  return isDefined2(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/shared/evm/initEvmProvider.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+
+// src/shared/evm/initInfuraProvider.ts
+import { assertEx as assertEx4, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { InfuraProvider } from "ethers/providers";
+var instance;
+var initInfuraProvider = /* @__PURE__ */ __name((context) => {
+  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) && isDefined3(config.evm?.infura?.projectId) && isDefined3(config.evm?.infura?.projectSecret);
+}, "canUseInfuraProvider");
+var getInfuraProviderConfig = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  const projectId = assertEx4(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx4(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  return [
+    getChainId(context),
+    projectId,
+    projectSecret
+  ];
+}, "getInfuraProviderConfig");
+
+// src/shared/evm/initJsonRpcProvider.ts
+import { assertEx as assertEx5, isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { JsonRpcProvider } from "ethers/providers";
+var initJsonRpcProvider = /* @__PURE__ */ __name((context) => {
+  const providerConfig = getJsonRpcProviderConfig(context);
+  return Promise.resolve(new JsonRpcProvider(...providerConfig));
+}, "initJsonRpcProvider");
+var canUseJsonRpcProvider = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  return canUseChainId(context) && isDefined4(config.evm.jsonRpc?.url);
+}, "canUseJsonRpcProvider");
+var getJsonRpcProviderConfig = /* @__PURE__ */ __name((context) => {
+  const { config } = context;
+  const jsonRpcUrl = assertEx5(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  return [
+    jsonRpcUrl,
+    getChainId(context)
+  ];
+}, "getJsonRpcProviderConfig");
+
+// src/shared/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 assertEx6(await provider, () => "No provider available");
+}, "initEvmProvider");
+var canUseEvmProvider = /* @__PURE__ */ __name((context) => {
+  return canUseInfuraProvider(context) || canUseJsonRpcProvider(context);
+}, "canUseEvmProvider");
+
+// src/shared/init/initEvmProvidersIfAvailable.ts
+async function initEvmProvidersIfAvailable(locator) {
+  const context = locator.context;
+  const { logger } = context;
+  if (canUseEvmProvider(context)) {
+    const chainId = assertEx7(context.config.chain.id, () => "Missing config.chain.id (required for EVM providers)");
+    const provider2 = await initEvmProvider(context);
+    const address = asEthAddress(chainId, true);
+    locator.register(EvmStakeEventsViewer.factory(EvmStakeEventsViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(EvmStakeViewer.factory(EvmStakeViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(EvmStakeTotalsViewer.factory(EvmStakeTotalsViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(EvmChainContractViewer.factory(EvmChainContractViewer.dependencies, {
+      address,
+      provider: provider2
+    }));
+    locator.register(SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {
+      ethProvider: provider2
+    }));
+  } else {
+    logger?.warn("EVM provider not available - running with memory based contract/stake viewers");
+    const positions = [];
+    locator.register(SimpleStakeEventsViewer.factory(SimpleStakeEventsViewer.dependencies, {
+      positions
+    }));
+    locator.register(SimpleStakeViewer.factory(SimpleStakeViewer.dependencies, {
+      positions
+    }));
+    locator.register(SimpleStakeTotalsViewer.factory(SimpleStakeTotalsViewer.dependencies, {}));
+    locator.register(SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
+      minWithdrawalBlocks: 10,
+      stakingTokenAddress: XYO_ZERO_ADDRESS,
+      rewardsContract: XYO_ZERO_ADDRESS
+    }));
+    locator.register(SimpleTimeSyncViewer2.factory(SimpleTimeSyncViewer2.dependencies, {}));
+  }
+  return locator;
+}
+__name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
+
+// src/shared/init/initStatusReporter.ts
+import { RuntimeStatusMonitor } from "@xyo-network/xl1-sdk";
+function initStatusReporter({ logger }) {
+  const statusReporter = new RuntimeStatusMonitor(logger);
+  statusReporter.onGlobalTransition({
+    to: "started"
+  }, () => {
+    logger.log("All services started.");
+  });
+  statusReporter.onGlobalTransition({
+    to: "error"
+  }, () => {
+    logger.error("Producer encountered an unhandled error!");
+    process.exit(1);
+  });
+  return statusReporter;
+}
+__name(initStatusReporter, "initStatusReporter");
+
+// src/shared/init/initWallet.ts
+import { isDefined as isDefined5 } 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 = isDefined5(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
+  return await HDWallet3.fromPhrase(seedPhrase);
+}
+__name(initActorWallet, "initActorWallet");
+
+// src/shared/config/locators/telemetryContextFromConfig.ts
+import { initTelemetry } from "@xyo-network/chain-telemetry";
+async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
+  return await initTelemetry({
+    attributes: {
+      serviceName,
+      serviceVersion
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  });
+}
+__name(telemetryContextFromConfig, "telemetryContextFromConfig");
+
+// src/shared/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
+  });
+  return {
+    ...telemetryConfig,
+    config,
+    singletons,
+    caches,
+    logger,
+    statusReporter
+  };
+}
+__name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
+
+// src/shared/config/locators/remoteLocatorFromConfig.ts
+import { JsonRpcAccountBalanceViewer, JsonRpcBlockViewer, JsonRpcFinalizationViewer, JsonRpcMempoolRunner, JsonRpcMempoolViewer, JsonRpcNetworkStakeViewer, JsonRpcStakeViewer, JsonRpcTransactionViewer, JsonRpcXyoViewer, ProviderFactoryLocator as ProviderFactoryLocator2, SimpleStakeEventsViewer as SimpleStakeEventsViewer2 } from "@xyo-network/xl1-sdk";
+function remoteLocatorFromConfig(context, validateDepsOnRegister = false) {
+  const locator = new ProviderFactoryLocator2(context, {}, validateDepsOnRegister);
+  locator.registerMany([
+    JsonRpcMempoolViewer.factory(JsonRpcMempoolViewer.dependencies, {}),
+    JsonRpcMempoolRunner.factory(JsonRpcMempoolRunner.dependencies, {}),
+    JsonRpcAccountBalanceViewer.factory(JsonRpcAccountBalanceViewer.dependencies, {}),
+    JsonRpcFinalizationViewer.factory(JsonRpcFinalizationViewer.dependencies, {}),
+    JsonRpcBlockViewer.factory(JsonRpcBlockViewer.dependencies, {}),
+    JsonRpcTransactionViewer.factory(JsonRpcTransactionViewer.dependencies, {}),
+    JsonRpcNetworkStakeViewer.factory(JsonRpcNetworkStakeViewer.dependencies, {}),
+    JsonRpcStakeViewer.factory(JsonRpcStakeViewer.dependencies, {}),
+    SimpleStakeEventsViewer2.factory(SimpleStakeEventsViewer2.dependencies, {
+      positions: []
+    }),
+    JsonRpcXyoViewer.factory(JsonRpcXyoViewer.dependencies, {})
+  ]);
+  return locator;
+}
+__name(remoteLocatorFromConfig, "remoteLocatorFromConfig");
+
+// src/shared/config/mergeConfig.ts
+import { deepMerge } from "@xylabs/sdk-js";
+function mergeConfig({ actors, ...baseConfig }) {
+  return {
+    ...baseConfig,
+    actors: actors.map((actor) => {
+      return deepMerge(baseConfig, actor);
+    })
+  };
+}
+__name(mergeConfig, "mergeConfig");
+
+// src/shared/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/shared/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/shared/host/implementation/DefaultServiceProvider.ts
+var DefaultServiceProvider = class {
+  static {
+    __name(this, "DefaultServiceProvider");
+  }
+  _services;
+  constructor(services) {
+    this._services = services;
+  }
+  getService(serviceIdentifier) {
+    return this._services[serviceIdentifier];
+  }
+};
+
+// src/shared/host/model/ServiceCollection.ts
+var ServiceLifetime = {
+  Singleton: "Singleton",
+  Transient: "Transient"
+};
+
+// src/shared/orchestrator/Orchestrator.ts
+import { AbstractCreatable, creatable as creatable2 } from "@xylabs/sdk-js";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var Orchestrator = class extends AbstractCreatable {
+  static {
+    __name(this, "Orchestrator");
+  }
+  actors = [];
+  keepAliveHandle = null;
+  running = false;
+  /**
+  * Registers an actor.
+  * (We won't activate the actor until `start()` is called.)
+  */
+  async registerActor(actor) {
+    if (this.running) {
+      await actor.start();
+    }
+    this.actors.push(actor);
+  }
+  /**
+  * Starts the orchestrator: activates all actors.
+  */
+  async startHandler() {
+    await super.startHandler();
+    if (this.running) {
+      this.logger?.warn("[Orchestrator] Already started.");
+      return;
+    }
+    this.logger?.log("[Orchestrator] Starting...");
+    this.running = true;
+    for (const actor of this.actors) {
+      await actor.start();
+    }
+    this.keepAliveHandle = setInterval(() => {
+    }, 2147483647);
+  }
+  /**
+  * Stops the orchestrator: deactivates all actors.
+  */
+  async stopHandler() {
+    await super.stopHandler();
+    if (!this.running) {
+      this.logger?.log("[Orchestrator] Already stopped.");
+      return;
+    }
+    this.logger?.log("[Orchestrator] Stopping...");
+    for (const actor of this.actors) {
+      await actor.stop();
+    }
+    this.running = false;
+    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle);
+    this.logger?.log("[Orchestrator] Stopped...");
+  }
+};
+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 assertEx9, 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 assertEx8 } 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 assertEx8(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 assertEx9(singleton8, () => "StakeIntentStateArchivist is undefined");
+    }, 2e3, true);
+  });
+}
+__name(initStakeIntentStateArchivist, "initStakeIntentStateArchivist");
+
+// src/node/config/locators/basicRemoteRunnerLocator.ts
+import { isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { isAccountInstance } from "@xyo-network/sdk-js";
+import { JsonRpcXyoRunner, JsonRpcXyoSigner, ProviderFactoryLocator as ProviderFactoryLocator5, RestDataLakeViewer as RestDataLakeViewer2, SimpleXyoConnectionRunner, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
+
+// src/node/config/locators/basicRemoteViewerLocator.ts
+import { assertEx as assertEx15, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { ActorConfigZod as ActorConfigZod2, BaseConfigZod, BlockViewerMoniker as BlockViewerMoniker2, JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer2, JsonRpcBlockViewer as JsonRpcBlockViewer2, ProviderFactoryLocator as ProviderFactoryLocator4, RestDataLakeViewer, SimpleTransactionViewer as SimpleTransactionViewer3, SimpleXyoConnectionViewer as SimpleXyoConnectionViewer2, SimpleXyoGateway } from "@xyo-network/xl1-sdk";
+
+// src/node/config/locators/localLocatorFromConfig.ts
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { ProviderFactoryLocator as ProviderFactoryLocator3, SimpleAccountBalanceViewer, SimpleBlockViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionViewer as SimpleTransactionViewer2, SimpleWindowedBlockViewer as SimpleWindowedBlockViewer2, SimpleXyoConnectionViewer, SimpleXyoViewer } from "@xyo-network/xl1-sdk";
+
+// src/node/init/initBalanceSummaryMap.ts
+import { BaseMongoSdk } from "@xylabs/mongo";
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { MongoMap } from "@xyo-network/chain-protocol";
+import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
+async function initBalanceSummaryMap({ logger, config }) {
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const sdkBalanceSummaryMap = new BaseMongoSdk({
+      ...payloadSdkConfig,
+      collection: "balance_summary_map"
+    });
+    const result = await MongoMap.create({
+      sdk: sdkBalanceSummaryMap,
+      getCache: {
+        enabled: true,
+        maxEntries: 5e3
+      }
+    });
+    assertEx10(await result.start(), () => "Failed to start transfer summary map");
+    return result;
+  } else {
+    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
+    return new MemoryMap();
+  }
+}
+__name(initBalanceSummaryMap, "initBalanceSummaryMap");
+
+// src/node/init/initFinalizationArchivistIfNeeded.ts
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { createBootstrapHead } from "@xyo-network/chain-sdk";
+import { Account } from "@xyo-network/sdk-js";
+import { asAttoXL1, findMostRecentBlock, flattenHydratedBlock } from "@xyo-network/xl1-sdk";
+async function initFinalizationArchivistIfNeeded(archivist, config, account) {
+  const configuredChainId = config.chain.id;
+  const possibleHead = await findMostRecentBlock(archivist);
+  if (configuredChainId && possibleHead && possibleHead.chain !== configuredChainId) {
+    throw new Error(`Configured chain ID (${configuredChainId}) does not match the existing chain ID (${possibleHead.chain})`);
+  }
+  let possibleChainId = configuredChainId;
+  if (!possibleHead) {
+    possibleChainId = possibleChainId ?? (await Account.random()).address;
+    const chain = await createBootstrapHead(account, possibleChainId, asAttoXL1(20000000000000000000000n), config.chain.genesisRewardAddress ?? account.address);
+    const payloads = chain.flatMap((block) => flattenHydratedBlock(block));
+    await archivist.insert(payloads);
+  }
+  const head = possibleHead ?? assertEx11(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
+  const chainId = assertEx11(possibleChainId, () => "Chain ID could not be determined");
+  return [
+    head,
+    chainId
+  ];
+}
+__name(initFinalizationArchivistIfNeeded, "initFinalizationArchivistIfNeeded");
+
+// src/node/init/initFinalizedArchivist.ts
+import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
+async function initMongoFinalizedArchivist(config) {
+  const payloadSdkConfig = {
+    ...config.storage.mongo,
+    collection: "chain_validated"
+  };
+  return await MongoDBArchivistV2.create({
+    payloadSdkConfig
+  });
+}
+__name(initMongoFinalizedArchivist, "initMongoFinalizedArchivist");
+async function initFinalizedArchivist(config) {
+  const finalizedArchivist = await initMongoFinalizedArchivist(config);
+  return finalizedArchivist;
+}
+__name(initFinalizedArchivist, "initFinalizedArchivist");
+
+// src/node/init/initServerNode.ts
+import { assertEx as assertEx12 } 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 { 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 } from "@xyo-network/module-abstract";
+import { MemoryArchivist as MemoryArchivist2, ModuleFactoryLocator } from "@xyo-network/sdk-js";
+import { MemorySentinel } from "@xyo-network/sentinel-memory";
+import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-sdk";
+var getLocator = /* @__PURE__ */ __name(async ({ logger, config }) => {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9465 } = config.telemetry?.metrics?.scrape ?? {};
+  const { traceProvider, meterProvider } = await initTelemetry2({
+    attributes: {
+      serviceName: "xl1-api",
+      serviceVersion: "1.0.0"
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  });
+  if (isDefined6(logger)) AbstractModule.defaultLogger = logger;
+  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
+  const locator = new ModuleFactoryLocator();
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig2(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const params = {
+      meterProvider,
+      payloadSdkConfig,
+      statusReporter,
+      traceProvider
+    };
+    locator.register(MongoDBArchivistV22.factory(params), void 0, true);
+    locator.register(MongoDBArchivistV2Deletable.factory(params), {
+      "network.xyo.storage.capabilities.delete": "enabled"
+    }, false);
+  }
+  locator.register(MemoryArchivist2.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(MemorySentinel.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(ViewArchivist.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  return locator;
+}, "getLocator");
+
+// src/node/manifest/loadNode.ts
+import { ManifestWrapper } from "@xyo-network/sdk-js";
+
+// src/node/manifest/node.json
+var node_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "44'/60'/1",
+        name: "XYOChain",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: []
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/node/manifest/nodeManifest.ts
+var NodeManifest = node_default;
+
+// src/node/manifest/private/index.ts
+var PrivateChildManifests = [];
+
+// src/node/manifest/public/Chain.json
+var Chain_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "1",
+        name: "Chain",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [
+          {
+            config: {
+              accountPath: "1/1'/1'",
+              name: "Validated",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              payloadSdkConfig: {
+                collection: "chain_validated"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          }
+        ],
+        public: [
+          {
+            config: {
+              accountPath: "1/1/1",
+              name: "Finalized",
+              allowedQueries: [
+                "network.xyo.query.archivist.get",
+                "network.xyo.query.archivist.next"
+              ],
+              getCache: {
+                enabled: true,
+                maxEntries: 5e4
+              },
+              originArchivist: "Validated",
+              schema: "network.xyo.archivist.view.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/node/manifest/public/Pending.json
+var Pending_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "2",
+        name: "Pending",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: [
+          {
+            config: {
+              accountPath: "2/1/1",
+              name: "Transactions",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              labels: {
+                "network.xyo.storage.capabilities.delete": "enabled",
+                "network.xyo.storage.class": "mongodb"
+              },
+              payloadSdkConfig: {
+                collection: "pending_transaction_bundles"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "2/1/2",
+              name: "Blocks",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              labels: {
+                "network.xyo.storage.capabilities.delete": "enabled",
+                "network.xyo.storage.class": "mongodb"
+              },
+              payloadSdkConfig: {
+                collection: "pending_block_bundles"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/node/manifest/public/index.ts
+var ChainNodeManifest = Chain_default;
+var PendingNodeManifest = Pending_default;
+var PublicChildManifests = [
+  ...ChainNodeManifest.nodes,
+  ...PendingNodeManifest.nodes
+];
+
+// src/node/manifest/loadNode.ts
+var loadNode = /* @__PURE__ */ __name(async (context, wallet) => {
+  const locator = await getLocator(context);
+  const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests);
+  const [node, ...childNodes] = await wrapper.loadNodes();
+  if (childNodes?.length > 0) {
+    await Promise.all(childNodes.map((childNode) => node.register(childNode)));
+    await Promise.all(childNodes.map((childNode) => node.attach(childNode.address, true)));
+  }
+  return node;
+}, "loadNode");
+
+// src/node/init/initServerNode.ts
+async function writableChainArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("Chain:Validated"), {
+    required: true
+  });
+}
+__name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
+async function readonlyChainArchivistFromNode(node) {
+  return assertEx12(asArchivistInstance(await node.resolve("Chain:Validated"), {
+    required: true
+  }));
+}
+__name(readonlyChainArchivistFromNode, "readonlyChainArchivistFromNode");
+async function pendingTransactionsArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("XYOChain:Pending:Transactions"), {
+    required: true
+  });
+}
+__name(pendingTransactionsArchivistFromNode, "pendingTransactionsArchivistFromNode");
+async function pendingBlocksArchivistFromNode(node) {
+  return asArchivistInstance(await node.resolve("XYOChain:Pending:Blocks"), {
+    required: true
+  });
+}
+__name(pendingBlocksArchivistFromNode, "pendingBlocksArchivistFromNode");
+async function initServerNode(context, wallet, providedNode) {
+  const node = providedNode ?? await loadNode(context, wallet);
+  assertEx12(await node.start(), () => "Failed to start node");
+  const writableChainArchivist = await writableChainArchivistFromNode(node);
+  const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
+  const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
+  const pendingBlocksArchivist = await pendingBlocksArchivistFromNode(node);
+  return {
+    node,
+    writableChainArchivist,
+    readonlyChainArchivist,
+    pendingTransactionsArchivist,
+    pendingBlocksArchivist
+  };
+}
+__name(initServerNode, "initServerNode");
+
+// src/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 { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-sdk";
+async function initTransferSummaryMap({ logger, config }) {
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig3(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const sdkTransferSummaryMap = new BaseMongoSdk2({
+      ...payloadSdkConfig,
+      collection: "transfer_summary_map"
+    });
+    const result = await MongoMap2.create({
+      sdk: sdkTransferSummaryMap,
+      getCache: {
+        enabled: true,
+        maxEntries: 5e3
+      }
+    });
+    assertEx13(await result.start(), () => "Failed to start transfer summary map");
+    return result;
+  } else {
+    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
+    return new MemoryMap2();
+  }
+}
+__name(initTransferSummaryMap, "initTransferSummaryMap");
+
+// src/node/config/locators/localLocatorFromConfig.ts
+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 wallet = await initActorWallet(context);
+  const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist } = await initServerNode(context, wallet);
+  await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet);
+  const locator = new ProviderFactoryLocator3(context, {}, validateDepsOnRegister);
+  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
+    }),
+    SimpleWindowedBlockViewer2.factory(SimpleWindowedBlockViewer2.dependencies, {
+      maxWindowSize: 1e4,
+      syncInterval: 1e4
+    }),
+    SimpleXyoConnectionViewer.factory(SimpleXyoConnectionViewer.dependencies, {}),
+    SimpleTransactionViewer2.factory(SimpleTransactionViewer2.dependencies, {}),
+    SimpleXyoViewer.factory(SimpleXyoViewer.dependencies, {}),
+    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, {
+      finalizedArchivist: readonlyChainArchivist
+    }),
+    SimpleFinalizationRunner.factory(SimpleFinalizationRunner.dependencies, {
+      finalizedArchivist: writableChainArchivist
+    })
+  ]);
+  return locator;
+}
+__name(localLocatorFromConfig, "localLocatorFromConfig");
+
+// src/node/config/locators/rootLocatorFromConfig.ts
+async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
+  const { config } = context;
+  let locator = await commonLocatorFromConfig(context, validateDepsOnRegister);
+  const newLocator = await (config.remote.rpc ? remoteLocatorFromConfig(locator.context, validateDepsOnRegister) : localLocatorFromConfig({
+    ...locator.context,
+    config: {
+      ...locator.context.config,
+      ...context.config
+    }
+  }, validateDepsOnRegister));
+  locator = newLocator;
+  locator = await initEvmProvidersIfAvailable(locator);
+  locator.freeze();
+  return locator;
+}
+__name(rootLocatorFromConfig, "rootLocatorFromConfig");
+
+// src/node/config/locators/basicRemoteViewerLocator.ts
+async function getChainIdFromRemote(remoteConfig) {
+  const locator = new ProviderFactoryLocator4({
+    config: BaseConfigZod.parse({
+      remote: remoteConfig
+    }),
+    singletons: {},
+    caches: {}
+  }, {}, true);
+  locator.registerMany([
+    JsonRpcBlockViewer2.factory(JsonRpcBlockViewer2.dependencies, {})
+  ]);
+  locator.freeze();
+  const blockViewer = await locator.getInstance(BlockViewerMoniker2);
+  return assertEx15(await blockViewer.chainId(), () => "Chain ID could not be determined from remote config");
+}
+__name(getChainIdFromRemote, "getChainIdFromRemote");
+async function basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint) {
+  const config = ActorConfigZod2.parse({
+    name,
+    remote: remoteConfig,
+    chain: {
+      id: chainId ?? await getChainIdFromRemote(remoteConfig)
+    }
+  });
+  const rootLocator = await rootLocatorFromConfig({
+    config,
+    singletons: {},
+    caches: {}
+  });
+  const remoteLocator = await remoteLocatorFromConfig(rootLocator.context);
+  const locator = new ProviderFactoryLocator4(remoteLocator.context, {});
+  locator.registerMany([
+    SimpleTransactionViewer3.factory(SimpleTransactionViewer3.dependencies, {}),
+    JsonRpcAccountBalanceViewer2.factory(JsonRpcAccountBalanceViewer2.dependencies, {}),
+    SimpleXyoConnectionViewer2.factory(SimpleXyoConnectionViewer2.dependencies, {}),
+    SimpleXyoGateway.factory(SimpleXyoGateway.dependencies, {})
+  ]);
+  if (isDefined7(dataLakeEndpoint)) {
+    const dataLakeViewerParams = {
+      endpoint: dataLakeEndpoint
+    };
+    locator.register(RestDataLakeViewer.factory(RestDataLakeViewer.dependencies, dataLakeViewerParams));
+  }
+  locator.freeze();
+  return locator;
+}
+__name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
+
+// src/node/config/locators/basicRemoteRunnerLocator.ts
+async function basicRemoteRunnerLocator(name, remoteConfig, signer, chainId, dataLakeEndpoint) {
+  const remoteViewerLocator = await basicRemoteViewerLocator(name, remoteConfig, chainId, dataLakeEndpoint);
+  const locator = new ProviderFactoryLocator5(remoteViewerLocator.context, {});
+  locator.registerMany([
+    SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}),
+    JsonRpcXyoRunner.factory(JsonRpcXyoRunner.dependencies, {})
+  ]);
+  if (isAccountInstance(signer)) {
+    locator.register(SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
+      account: signer
+    }));
+  } else {
+    locator.register(JsonRpcXyoSigner.factory(JsonRpcXyoSigner.dependencies, {
+      transport: signer
+    }));
+  }
+  if (isDefined8(dataLakeEndpoint)) {
+    const dataLakeViewerParams = {
+      endpoint: dataLakeEndpoint
+    };
+    locator.register(RestDataLakeViewer2.factory(RestDataLakeViewer2.dependencies, dataLakeViewerParams));
+  }
+  locator.freeze();
+  return locator;
+}
+__name(basicRemoteRunnerLocator, "basicRemoteRunnerLocator");
+
+// src/node/config/locators/locatorsFromConfig.ts
+import { deepMerge as deepMerge2 } from "@xylabs/sdk-js";
+import { ActorConfigZod as ActorConfigZod3 } from "@xyo-network/xl1-sdk";
+
+// src/node/config/locators/actors/apiLocatorFromConfig.ts
+import { ProviderFactoryLocator as ProviderFactoryLocator6, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner2, SimpleXyoGateway as SimpleXyoGateway2, SimpleXyoRunner } from "@xyo-network/xl1-sdk";
+function apiLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator6({
+    ...context,
+    locator: parent
+  });
+  locator.registerMany([
+    SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}),
+    SimpleXyoConnectionRunner2.factory(SimpleXyoConnectionRunner2.dependencies, {}),
+    SimpleXyoGateway2.factory(SimpleXyoGateway2.dependencies, {})
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(apiLocatorFromConfig, "apiLocatorFromConfig");
+
+// src/node/config/locators/actors/bridgeLocatorFromConfig.ts
+import { isDefined as isDefined9 } 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 as JsonRpcBlockViewer3, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer2, JsonRpcMempoolRunner as JsonRpcMempoolRunner2, JsonRpcMempoolViewer as JsonRpcMempoolViewer2, JsonRpcXyoRunner as JsonRpcXyoRunner2, JsonRpcXyoViewer as JsonRpcXyoViewer2, ProviderFactoryLocator as ProviderFactoryLocator7, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner3, SimpleXyoGatewayRunner, SimpleXyoRunner as SimpleXyoRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-sdk";
+async function bridgeLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator7({
+    ...context,
+    locator: parent
+  });
+  const { config } = context;
+  const { mnemonic } = config;
+  const walletPhrase = isDefined9(mnemonic) ? mnemonic : HDWallet4.generateMnemonic();
+  const wallet = await generateXyoBaseWalletFromPhrase2(walletPhrase);
+  const signerAccount = await wallet.derivePath(ADDRESS_INDEX2.XYO);
+  if (config.remote.rpc) {
+    locator.registerMany([
+      JsonRpcMempoolViewer2.factory(JsonRpcMempoolViewer2.dependencies, {}),
+      JsonRpcMempoolRunner2.factory(JsonRpcMempoolRunner2.dependencies, {}),
+      JsonRpcAccountBalanceViewer3.factory(JsonRpcAccountBalanceViewer3.dependencies, {}),
+      JsonRpcFinalizationViewer2.factory(JsonRpcFinalizationViewer2.dependencies, {}),
+      JsonRpcBlockViewer3.factory(JsonRpcBlockViewer3.dependencies, {}),
+      JsonRpcXyoRunner2.factory(JsonRpcXyoRunner2.dependencies, {}),
+      JsonRpcXyoViewer2.factory(JsonRpcXyoViewer2.dependencies, {})
+    ]);
+  }
+  locator.registerMany([
+    SimpleXyoSigner2.factory(SimpleXyoSigner2.dependencies, {
+      account: signerAccount
+    }),
+    SimpleXyoRunner2.factory(SimpleXyoRunner2.dependencies, {}),
+    SimpleXyoConnectionRunner3.factory(SimpleXyoConnectionRunner3.dependencies, {}),
+    SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {})
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(bridgeLocatorFromConfig, "bridgeLocatorFromConfig");
+
+// src/node/config/locators/actors/mempoolLocatorFromConfig.ts
+import { ProviderFactoryLocator as ProviderFactoryLocator8 } from "@xyo-network/xl1-sdk";
+function mempoolLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator8({
+    ...context,
+    locator: parent
+  });
+  locator.registerMany([]);
+  locator.freeze();
+  return locator;
+}
+__name(mempoolLocatorFromConfig, "mempoolLocatorFromConfig");
+
+// src/node/config/locators/actors/producerLocatorFromConfig.ts
+import { asAddress as asAddress2 } from "@xylabs/sdk-js";
+import { SimpleBlockRunner } from "@xyo-network/chain-services";
+import { ProviderFactoryLocator as ProviderFactoryLocator9 } from "@xyo-network/xl1-sdk";
+async function producerLocatorFromConfig(context, parent) {
+  const { logger, config } = context;
+  const account = await initActorAccount(context);
+  const locator = new ProviderFactoryLocator9({
+    ...context,
+    locator: parent
+  });
+  const rewardAddress = asAddress2(config.rewardAddress ?? account.address, true);
+  logger?.info(`Using reward address ${rewardAddress}`);
+  if (rewardAddress === account.address) {
+    logger?.warn(`Using producer account address as reward address: ${account.address}`);
+  }
+  locator.registerMany([
+    SimpleBlockRunner.factory(SimpleBlockRunner.dependencies, {
+      account,
+      rewardAddress
+    })
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(producerLocatorFromConfig, "producerLocatorFromConfig");
+
+// src/node/config/locators/actors/rewardRedemptionLocatorFromConfig.ts
+import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer4, JsonRpcBlockViewer as JsonRpcBlockViewer4, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer3, JsonRpcMempoolRunner as JsonRpcMempoolRunner3, JsonRpcMempoolViewer as JsonRpcMempoolViewer3, JsonRpcXyoRunner as JsonRpcXyoRunner3, JsonRpcXyoViewer as JsonRpcXyoViewer3, ProviderFactoryLocator as ProviderFactoryLocator10, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner4, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoRunner as SimpleXyoRunner3, SimpleXyoSigner as SimpleXyoSigner3 } from "@xyo-network/xl1-sdk";
+async function rewardRedemptionLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator10({
+    ...context,
+    locator: parent
+  });
+  const { config } = context;
+  const account = await initActorAccount(context);
+  if (config.remote.rpc) {
+    locator.registerMany([
+      JsonRpcMempoolViewer3.factory(JsonRpcMempoolViewer3.dependencies, {}),
+      JsonRpcMempoolRunner3.factory(JsonRpcMempoolRunner3.dependencies, {}),
+      JsonRpcAccountBalanceViewer4.factory(JsonRpcAccountBalanceViewer4.dependencies, {}),
+      JsonRpcFinalizationViewer3.factory(JsonRpcFinalizationViewer3.dependencies, {}),
+      JsonRpcBlockViewer4.factory(JsonRpcBlockViewer4.dependencies, {}),
+      JsonRpcXyoRunner3.factory(JsonRpcXyoRunner3.dependencies, {}),
+      JsonRpcXyoViewer3.factory(JsonRpcXyoViewer3.dependencies, {})
+    ]);
+  }
+  locator.registerMany([
+    SimpleXyoSigner3.factory(SimpleXyoSigner3.dependencies, {
+      account
+    }),
+    SimpleXyoRunner3.factory(SimpleXyoRunner3.dependencies, {}),
+    SimpleXyoConnectionRunner4.factory(SimpleXyoConnectionRunner4.dependencies, {}),
+    SimpleXyoGatewayRunner2.factory(SimpleXyoGatewayRunner2.dependencies, {})
+  ]);
+  locator.freeze();
+  return locator;
+}
+__name(rewardRedemptionLocatorFromConfig, "rewardRedemptionLocatorFromConfig");
+
+// src/node/config/locators/actors/validatorLocatorFromConfig.ts
+import { ProviderFactoryLocator as ProviderFactoryLocator11 } from "@xyo-network/xl1-sdk";
+function validatorLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator11({
+    ...context,
+    locator: parent
+  });
+  locator.registerMany([]);
+  locator.freeze();
+  return locator;
+}
+__name(validatorLocatorFromConfig, "validatorLocatorFromConfig");
+
+// src/node/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(deepMerge2(config, actorConfig))
+        }, result._root);
+        break;
+      }
+      case "api": {
+        result[actorConfig.name] = await apiLocatorFromConfig({
+          ...context,
+          config: ApiConfigZod.parse(deepMerge2(config, actorConfig))
+        }, result._root);
+        break;
+      }
+      case "mempool": {
+        result[actorConfig.name] = await mempoolLocatorFromConfig({
+          ...context,
+          config: MempoolConfigZod.parse(deepMerge2(config, actorConfig))
+        }, result._root);
+        break;
+      }
+      case "validator": {
+        result[actorConfig.name] = await validatorLocatorFromConfig({
+          ...context,
+          config: ActorConfigZod3.parse(deepMerge2(config, actorConfig))
+        }, result._root);
+        break;
+      }
+      case "bridge": {
+        result[actorConfig.name] = await bridgeLocatorFromConfig({
+          ...context,
+          config: BridgeConfigZod.parse(deepMerge2(config, actorConfig))
+        }, result._root);
+        break;
+      }
+      case "rewardRedemption": {
+        result[actorConfig.name] = await rewardRedemptionLocatorFromConfig({
+          ...context,
+          config: RewardRedemptionConfigZod.parse(deepMerge2(config, actorConfig))
+        }, result._root);
+        break;
+      }
+    }
+  }
+  return result;
+}
+__name(locatorsFromConfig, "locatorsFromConfig");
+
+// src/node/config/tryParseConfig.ts
+import { isDefined as isDefined10, 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 (isDefined10(result) && !isNull(result)) {
+    const section = result[configSection];
+    if (isDefined10(section) && typeof section === "object") {
+      return ConfigZod.loose().parse(section);
+    }
+  }
+  return ConfigZod.parse({});
+}
+__name(tryParseConfig, "tryParseConfig");
+
+// src/node/health/initHealthEndpoints.ts
+import http from "http";
+import { isDefined as isDefined11 } 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 isDefined11(healthCheckPort) ? createHealthServer(context, healthCheckPort, statusMonitor) : void 0;
+}
+__name(initHealthEndpoints, "initHealthEndpoints");
+export {
+  ApiConfigContext,
+  ApiConfigZod,
+  BasisPointsZod,
+  BridgeConfigContext,
+  BridgeConfigZod,
+  BridgeSettingsZod,
+  DefaultServiceProvider,
+  GenericHost,
+  MempoolConfigContext,
+  MempoolConfigZod,
+  NodeManifest,
+  Orchestrator,
+  PrivateChildManifests,
+  ProducerConfigContext,
+  ProducerConfigZod,
+  PublicChildManifests,
+  RewardRedemptionConfigContext,
+  RewardRedemptionConfigZod,
+  ServiceLifetime,
+  ValidatorActor,
+  asApiConfig,
+  asApiConfigContext,
+  asBridgeConfig,
+  asBridgeConfigContext,
+  asMempoolConfig,
+  asMempoolConfigContext,
+  asProducerConfig,
+  asProducerConfigContext,
+  asRewardRedemptionConfig,
+  asRewardRedemptionConfigContext,
+  basicRemoteRunnerLocator,
+  basicRemoteViewerLocator,
+  buildTelemetryConfig,
+  canUseChainId,
+  canUseEvmProvider,
+  canUseInfuraProvider,
+  canUseJsonRpcProvider,
+  commonLocatorFromConfig,
+  contextFromConfigWithoutLocator,
+  createProducerChainStakeIntentBlock,
+  getChainId,
+  getInfuraProviderConfig,
+  getJsonRpcProviderConfig,
+  getLocator,
+  initActorAccount,
+  initActorSeedPhrase,
+  initActorWallet,
+  initBalanceSummaryMap,
+  initBridgedArchivistModule,
+  initBridgedModule,
+  initChainFinalizedArchivist,
+  initEvmProvider,
+  initEvmProvidersIfAvailable,
+  initFinalizationArchivistIfNeeded,
+  initFinalizedArchivist,
+  initHealthEndpoints,
+  initInfuraProvider,
+  initJsonRpcProvider,
+  initPendingBlocksArchivist,
+  initRejectedTransactionsArchivist,
+  initServerNode,
+  initStakeIntentStateArchivist,
+  initStatusReporter,
+  initTransferSummaryMap,
+  isApiConfig,
+  isApiConfigContext,
+  isBridgeConfig,
+  isBridgeConfigContext,
+  isMempoolConfig,
+  isMempoolConfigContext,
+  isProducerConfig,
+  isProducerConfigContext,
+  isRewardRedemptionConfig,
+  isRewardRedemptionConfigContext,
+  loadNode,
+  localLocatorFromConfig,
+  locatorsFromConfig,
+  mergeConfig,
+  remoteLocatorFromConfig,
+  rootLocatorFromConfig,
+  telemetryContextFromConfig,
+  toApiConfig,
+  toApiConfigContext,
+  toBridgeConfig,
+  toBridgeConfigContext,
+  toMempoolConfig,
+  toMempoolConfigContext,
+  toProducerConfig,
+  toProducerConfigContext,
+  toRewardRedemptionConfig,
+  toRewardRedemptionConfigContext,
+  tryParseConfig
+};
+//# sourceMappingURL=index.mjs.map