@xyo-network/chain-orchestration 1.20.18 → 1.20.19

package/dist/browser/index.mjs

@@ -53,7 +53,7 @@ var ValidatorActor = class extends ActorV3 {
     await super.startHandler();
     this.registerTimer("ValidatorActor", async () => {
       await this.spanAsync("processPendingBlocks", async () => {
-        console.log("ValidatorActor: Processing pending blocks...");
+        this.logger?.debug("ValidatorActor: Processing pending blocks...");
         await processPendingBlocks({
           blockValidationViewer: this.blockValidationViewer,
           context: this.context,
@@ -98,13 +98,24 @@ __name(buildTelemetryConfig, "buildTelemetryConfig");
 // src/shared/config/actors/Api.ts
 import { zodAsFactory, zodIsFactory, zodToFactory } from "@xylabs/sdk-js";
 import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
+import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+
+// src/shared/config/actors/accountIndex.ts
 import { globalRegistry, z } from "zod";
-var ApiConfigZod = HostActorConfigZod.extend(z.object({
-  initRewardsCache: z.union([
-    z.number(),
-    z.string(),
-    z.boolean()
-  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry, {
+var ActorAccountIndexZod = /* @__PURE__ */ __name((title) => z.coerce.number().int().min(0).optional().register(globalRegistry, {
+  description: "Account index derived from the actor wallet phrase. Defaults to 0 for actor mnemonics and to the actor-specific shared index for the root mnemonic.",
+  title,
+  type: "number"
+}), "ActorAccountIndexZod");
+
+// src/shared/config/actors/Api.ts
+var ApiConfigZod = HostActorConfigZod.extend(z2.object({
+  accountIndex: ActorAccountIndexZod("api.accountIndex"),
+  initRewardsCache: z2.union([
+    z2.number(),
+    z2.string(),
+    z2.boolean()
+  ]).transform((v) => v !== "0" && v !== "false" && v !== false && v != 0).default(true).register(globalRegistry2, {
     description: "Whether to initialize the rewards cache on startup",
     title: "api.initRewardsCache",
     type: "boolean"
@@ -123,7 +134,7 @@ var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
 // src/shared/config/actors/Bridge.ts
 import { AddressZod, HexZod, toAddress, toHex, zodAsFactory as zodAsFactory2, zodIsFactory as zodIsFactory2, zodToFactory as zodToFactory2 } from "@xylabs/sdk-js";
 import { AttoXL1ConvertFactor, BaseConfigContextZod as BaseConfigContextZod2, HostActorConfigZod as HostActorConfigZod2, XL1 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+import { globalRegistry as globalRegistry3, z as z3 } from "zod";
 var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
 var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
@@ -132,83 +143,84 @@ var DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY = toHex("0xac0974bec39a17e36
 var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f64180aa3");
 var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(1000000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
-var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
+var BasisPointsZod = z3.coerce.number().int().nonnegative().max(1e4);
 var BridgeConfigZod = HostActorConfigZod2.extend({
-  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+  accountIndex: ActorAccountIndexZod("bridge.accountIndex"),
+  escrowAddress: AddressZod.optional().register(globalRegistry3, {
     description: "Address to which bridge escrow will be sent",
     title: "bridge.escrowAddress",
     type: "string"
   }),
-  feesAddress: AddressZod.optional().register(globalRegistry2, {
+  feesAddress: AddressZod.optional().register(globalRegistry3, {
     description: "Address to which bridge fees will be sent",
     title: "bridge.feesAddress",
     type: "string"
   }),
-  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry2, {
+  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry3, {
     default: DEFAULT_FIXED_FEE,
     description: "Fixed fee (in AttoXL1) applied to bridge transfers",
     title: "bridge.feeFixed",
     type: "bigint"
   }),
-  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry3, {
     default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
     description: "Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers",
     title: "bridge.feeRateBasisPoints",
     type: "number"
   }),
-  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
+  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry3, {
     default: DEFAULT_MAX_BRIDGE_AMOUNT,
     description: "Maximum amount allowed for a bridge transfer",
     title: "bridge.maxBridgeAmount",
     type: "string"
   }),
-  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry2, {
+  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry3, {
     default: DEFAULT_MIN_BRIDGE_AMOUNT,
     description: "Minimum amount required for a bridge transfer",
     title: "bridge.minBridgeAmount",
     type: "string"
   }),
-  redisHost: z2.string().default("localhost").register(globalRegistry2, {
+  redisHost: z3.string().default("localhost").register(globalRegistry3, {
     default: "localhost",
     description: "Host for the Bridge Redis instance",
     title: "bridge.redisHost",
     type: "string"
   }),
-  redisPort: z2.coerce.number().int().positive().default(6379).register(globalRegistry2, {
+  redisPort: z3.coerce.number().int().positive().default(6379).register(globalRegistry3, {
     default: 6379,
     description: "Port for the Bridge Redis instance",
     title: "bridge.redisPort",
     type: "number"
   }),
-  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
+  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry3, {
     default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteBridgeContractAddress",
     type: "string"
   }),
-  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
+  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry3, {
     default: DEFAULT_HARDHAT_CHAIN_ID,
     description: "Remote chain ID",
     title: "bridge.remoteChainId",
     type: "string"
   }),
-  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
+  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry3, {
     default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteTokenAddress",
     type: "string"
   }),
-  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
+  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry3, {
     description: "Private key for the wallet to use for the remote chain wallet",
     title: "bridge.remoteChainWalletPrivateKey",
     type: "string"
   }),
-  xl1ChainId: HexZod.optional().register(globalRegistry2, {
+  xl1ChainId: HexZod.optional().register(globalRegistry3, {
     description: "XL1 chain id used for bridging",
     title: "bridge.xl1ChainId",
     type: "string"
   }),
-  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
+  xl1TokenAddress: HexZod.optional().register(globalRegistry3, {
     description: "XL1 token address used for bridging",
     title: "bridge.xl1TokenAddress",
     type: "string"
@@ -239,11 +251,12 @@ var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigCo
 // src/shared/config/actors/Mempool.ts
 import { zodAsFactory as zodAsFactory3, zodIsFactory as zodIsFactory3, zodToFactory as zodToFactory3 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod3, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+import { globalRegistry as globalRegistry4, z as z4 } from "zod";
 var MempoolConfigZod = HostActorConfigZod3.extend({
-  enabled: z3.union([
-    z3.string(),
-    z3.boolean()
+  accountIndex: ActorAccountIndexZod("mempool.accountIndex"),
+  enabled: z4.union([
+    z4.string(),
+    z4.boolean()
   ]).default("false").transform((val, ctx) => {
     if (typeof val === "boolean") return val;
     const normalized = val.toLowerCase().trim();
@@ -264,8 +277,8 @@ var MempoolConfigZod = HostActorConfigZod3.extend({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z3.NEVER;
-  }).register(globalRegistry3, {
+    return z4.NEVER;
+  }).register(globalRegistry4, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
@@ -285,42 +298,43 @@ var toMempoolConfigContext = zodToFactory3(MempoolConfigContext, "toMempoolConfi
 // src/shared/config/actors/Producer.ts
 import { AddressZod as AddressZod2, asAddress, zodAsFactory as zodAsFactory4, zodIsFactory as zodIsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/sdk-js";
 import { ActorConfigZod, BaseConfigContextZod as BaseConfigContextZod4 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry4, z as z4 } from "zod";
+import { globalRegistry as globalRegistry5, z as z5 } from "zod";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
-var ProducerConfigZod = ActorConfigZod.extend(z4.object({
-  allowlist: z4.preprocess((val) => {
+var ProducerConfigZod = ActorConfigZod.extend(z5.object({
+  accountIndex: ActorAccountIndexZod("producer.accountIndex"),
+  allowlist: z5.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z4.array(AddressZod2).optional().register(globalRegistry4, {
+  }, z5.array(AddressZod2).optional().register(globalRegistry5, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  blockProductionCheckInterval: z4.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
+  blockProductionCheckInterval: z5.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry5, {
     description: "The interval time (in milliseconds) between block production attempts",
     title: "producer.blockProductionCheckInterval",
     type: "number"
   }),
-  disableIntentRedeclaration: z4.boolean().optional().register(globalRegistry4, {
+  disableIntentRedeclaration: z5.boolean().optional().register(globalRegistry5, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
-  heartbeatInterval: z4.coerce.number().default(36e5).register(globalRegistry4, {
+  heartbeatInterval: z5.coerce.number().default(36e5).register(globalRegistry5, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z4.coerce.number().default(1).register(globalRegistry4, {
+  minStake: z5.coerce.number().default(1).register(globalRegistry5, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z4.string().optional().register(globalRegistry4, {
+  rewardAddress: z5.string().optional().register(globalRegistry5, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -339,7 +353,9 @@ var toProducerConfigContext = zodToFactory4(ProducerConfigContext, "toProducerCo
 // src/shared/config/actors/RewardRedemption.ts
 import { zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod5, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
-var RewardRedemptionConfigZod = HostActorConfigZod4.extend({});
+var RewardRedemptionConfigZod = HostActorConfigZod4.extend({
+  accountIndex: ActorAccountIndexZod("rewardRedemption.accountIndex")
+});
 var isRewardRedemptionConfig = zodIsFactory5(RewardRedemptionConfigZod);
 var asRewardRedemptionConfig = zodAsFactory5(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
 var toRewardRedemptionConfig = zodToFactory5(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
@@ -353,10 +369,11 @@ var toRewardRedemptionConfigContext = zodToFactory5(RewardRedemptionConfigContex
 // src/shared/config/actors/Validator.ts
 import { AddressZod as AddressZod3, zodAsFactory as zodAsFactory6, zodIsFactory as zodIsFactory6, zodToFactory as zodToFactory6 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod6, HostActorConfigZod as HostActorConfigZod5 } from "@xyo-network/xl1-sdk";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var ValidatorConfigZod = HostActorConfigZod5.extend({
-  allowedProducers: z5.array(AddressZod3).optional(),
-  minCandidates: z5.number().int().min(0).optional()
+  accountIndex: ActorAccountIndexZod("validator.accountIndex"),
+  allowedProducers: z6.array(AddressZod3).optional(),
+  minCandidates: z6.number().int().min(0).optional()
 });
 var isValidatorConfig = zodIsFactory6(ValidatorConfigZod);
 var asValidatorConfig = zodAsFactory6(ValidatorConfigZod, "asValidatorConfig");
@@ -433,26 +450,279 @@ var ServiceLifetime = {
 };
 
 // src/shared/init/initActorAccount.ts
-import { isDefined, isUndefined } from "@xylabs/sdk-js";
-import { HDWallet } from "@xyo-network/sdk-js";
-import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+import { isDefined } from "@xylabs/sdk-js";
+
+// src/shared/init/walletResolution.ts
+import { DEFAULT_WALLET_PATH, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+var BUILT_IN_DEV_MNEMONIC = "crane ribbon cook cousin tobacco vital moral protect merit knock veteran hint knee ocean nurse";
+var INSECURE_GENESIS_REWARD_MNEMONIC = "test test test test test test test test test test test junk";
+var GENESIS_REWARD_AMOUNT = 20000000000000000000000n;
+var ATTO_XL1_PER_XL1 = 1000000000000000000n;
+var ROOT_WALLET_RUNTIME_ID = "_root";
+var SHARED_ACCOUNT_REPORT_COUNT = 10;
+var RESERVED_ACTOR_INDEX = {
+  [ROOT_WALLET_RUNTIME_ID]: 0,
+  api: 4,
+  bridge: 2,
+  mempool: 5,
+  producer: 1,
+  rewardRedemption: 3,
+  validator: 6
+};
+var ACTOR_LABELS = {
+  [ROOT_WALLET_RUNTIME_ID]: "root/local-node",
+  api: "api",
+  bridge: "bridge",
+  mempool: "mempool",
+  producer: "producer",
+  rewardRedemption: "rewardRedemption",
+  validator: "validator"
+};
+var activeWalletReport;
+function getAccountLabel(actorName) {
+  return ACTOR_LABELS[actorName] ?? actorName;
+}
+__name(getAccountLabel, "getAccountLabel");
+function clearResolvedWalletReport() {
+  activeWalletReport = void 0;
+}
+__name(clearResolvedWalletReport, "clearResolvedWalletReport");
+function getReservedActorIndex(actorName) {
+  return RESERVED_ACTOR_INDEX[actorName] ?? 0;
+}
+__name(getReservedActorIndex, "getReservedActorIndex");
+function getBuiltInDevMnemonic() {
+  return BUILT_IN_DEV_MNEMONIC;
+}
+__name(getBuiltInDevMnemonic, "getBuiltInDevMnemonic");
+function getInsecureGenesisRewardMnemonic() {
+  return INSECURE_GENESIS_REWARD_MNEMONIC;
+}
+__name(getInsecureGenesisRewardMnemonic, "getInsecureGenesisRewardMnemonic");
+function resolveRootWallet(configuration) {
+  const mnemonic = configuration.mnemonic ?? BUILT_IN_DEV_MNEMONIC;
+  const isBuiltInDevMnemonic = mnemonic === BUILT_IN_DEV_MNEMONIC;
+  return {
+    basePath: DEFAULT_WALLET_PATH,
+    isBuiltInDevMnemonic,
+    mnemonic,
+    mnemonicKind: isBuiltInDevMnemonic ? "built-in-dev" : "configured-root"
+  };
+}
+__name(resolveRootWallet, "resolveRootWallet");
+async function resolveWalletMetadata({ accountIndex, actorName, mnemonic, mnemonicKind, source }) {
+  const wallet = await generateXyoBaseWalletFromPhrase(mnemonic);
+  const derivationPath = `${DEFAULT_WALLET_PATH}/${accountIndex}`;
+  const account = await wallet.derivePath(`${accountIndex}`);
+  return {
+    accountIndex,
+    actorName,
+    address: account.address,
+    derivationPath,
+    label: getAccountLabel(actorName),
+    mnemonic,
+    mnemonicKind,
+    privateKey: account.privateKey,
+    source,
+    usesBuiltInDevMnemonic: mnemonic === BUILT_IN_DEV_MNEMONIC
+  };
+}
+__name(resolveWalletMetadata, "resolveWalletMetadata");
+async function resolveActorWallet(actorName, actorConfig, root) {
+  const actorMnemonic = actorConfig?.mnemonic;
+  const accountIndex = actorConfig?.accountIndex;
+  return await resolveWalletMetadata(actorMnemonic ? {
+    accountIndex: accountIndex ?? 0,
+    actorName,
+    mnemonic: actorMnemonic,
+    mnemonicKind: "configured-actor",
+    source: "actor"
+  } : {
+    accountIndex: accountIndex ?? getReservedActorIndex(actorName),
+    actorName,
+    mnemonic: root.mnemonic,
+    mnemonicKind: root.mnemonicKind,
+    source: "root"
+  });
+}
+__name(resolveActorWallet, "resolveActorWallet");
+async function resolveWalletReport(requestedActors, configuration) {
+  const root = resolveRootWallet(configuration);
+  const actorConfigMap = new Map(configuration.actors.map((actor) => [
+    actor.name,
+    actor
+  ]));
+  const resolvedActors = await Promise.all(requestedActors.map(async (actorName) => await resolveActorWallet(actorName, actorConfigMap.get(actorName), root)));
+  const labelMap = /* @__PURE__ */ new Map([
+    [
+      0,
+      [
+        getAccountLabel(ROOT_WALLET_RUNTIME_ID)
+      ]
+    ]
+  ]);
+  for (const actor of resolvedActors) {
+    if (actor.source !== "root") continue;
+    const labels = labelMap.get(actor.accountIndex) ?? [];
+    labels.push(actor.label);
+    labelMap.set(actor.accountIndex, labels);
+  }
+  const sharedAccounts = await Promise.all(Array.from({
+    length: SHARED_ACCOUNT_REPORT_COUNT
+  }, (_, index) => index).map(async (accountIndex) => {
+    const account = await resolveWalletMetadata({
+      accountIndex,
+      actorName: ROOT_WALLET_RUNTIME_ID,
+      mnemonic: root.mnemonic,
+      mnemonicKind: root.mnemonicKind,
+      source: "root"
+    });
+    const labels = labelMap.get(accountIndex);
+    return {
+      ...account,
+      label: labels?.join(", ") ?? `shared[${accountIndex}]`
+    };
+  }));
+  const insecureGenesisRewardAccounts = configuration.chain.genesisRewardAddress ? void 0 : await Promise.all(Array.from({
+    length: SHARED_ACCOUNT_REPORT_COUNT
+  }, (_, index) => index).map(async (accountIndex) => {
+    const account = await resolveWalletMetadata({
+      accountIndex,
+      actorName: "genesisReward",
+      mnemonic: INSECURE_GENESIS_REWARD_MNEMONIC,
+      mnemonicKind: "configured-actor",
+      source: "actor"
+    });
+    return {
+      ...account,
+      label: accountIndex === 0 ? "genesisRewardAddress" : `genesisReward[${accountIndex}]`
+    };
+  }));
+  return {
+    actorSpecificAccounts: resolvedActors.filter((actor) => actor.source === "actor"),
+    insecureGenesisRewardAccounts,
+    requestedActors: [
+      ...requestedActors
+    ],
+    root,
+    sharedAccounts
+  };
+}
+__name(resolveWalletReport, "resolveWalletReport");
+async function initializeResolvedWalletReport(requestedActors, configuration) {
+  activeWalletReport = await resolveWalletReport(requestedActors, configuration);
+  return activeWalletReport;
+}
+__name(initializeResolvedWalletReport, "initializeResolvedWalletReport");
+function getResolvedWalletReport() {
+  return activeWalletReport;
+}
+__name(getResolvedWalletReport, "getResolvedWalletReport");
+function formatSharedAccount(account, showPrivateKey) {
+  const lines = [
+    `[${account.accountIndex}] ${account.label}`,
+    `source: ${account.mnemonicKind === "built-in-dev" ? "built-in dev mnemonic" : "configured root mnemonic"}`,
+    `path: ${account.derivationPath}`,
+    `address: ${account.address}`
+  ];
+  if (showPrivateKey) lines.push(`privateKey: ${account.privateKey ?? "unavailable"}`);
+  return lines.join("\n");
+}
+__name(formatSharedAccount, "formatSharedAccount");
+function formatActorSpecificAccount(account) {
+  return [
+    account.label,
+    "source: actor mnemonic",
+    `path: ${account.derivationPath}`,
+    `address: ${account.address}`
+  ].join("\n");
+}
+__name(formatActorSpecificAccount, "formatActorSpecificAccount");
+function formatGenesisRewardAccount(account) {
+  const balance = account.accountIndex === 0 ? GENESIS_REWARD_AMOUNT / ATTO_XL1_PER_XL1 : 0n;
+  return [
+    `[${account.accountIndex}] ${account.label}`,
+    `path: ${account.derivationPath}`,
+    `address: ${account.address}`,
+    `privateKey: ${account.privateKey ?? "unavailable"}`,
+    `balance: ${balance.toString()} XL1`
+  ].join("\n");
+}
+__name(formatGenesisRewardAccount, "formatGenesisRewardAccount");
+function formatWalletReport(report) {
+  const sections = [];
+  const showSecrets = report.root.isBuiltInDevMnemonic;
+  sections.push(showSecrets ? "Development wallet detected." : "Wallet summary");
+  if (showSecrets) {
+    sections.push([
+      "DEVELOPMENT WALLET WARNING",
+      "",
+      "XL1 is using the built-in development mnemonic.",
+      "This mnemonic is fixed, public, and does not change between runs.",
+      "The addresses and private keys below are unsafe and must never be used for real funds, production systems, or shared environments.",
+      "Anyone with this information can fully control these accounts.",
+      "",
+      "Mnemonic:",
+      report.root.mnemonic
+    ].join("\n"));
+  }
+  sections.push([
+    `Shared wallet accounts from ${report.root.basePath}:`,
+    "",
+    report.sharedAccounts.map((account) => formatSharedAccount(account, showSecrets)).join("\n\n")
+  ].join("\n"));
+  if (report.actorSpecificAccounts.length > 0) {
+    sections.push([
+      "Actor-specific wallet accounts:",
+      "",
+      report.actorSpecificAccounts.map((account) => formatActorSpecificAccount(account)).join("\n\n")
+    ].join("\n"));
+  }
+  if (report.insecureGenesisRewardAccounts) {
+    sections.push([
+      "INSECURE GENESIS REWARD WALLET WARNING",
+      "",
+      "XL1 is using a public, insecure fallback wallet for the genesis reward address.",
+      "This phrase is intentionally unsafe and must never be used for real funds, production systems, or shared environments.",
+      "Anyone with this information can fully control the genesis reward wallet.",
+      "",
+      "Genesis reward phrase:",
+      INSECURE_GENESIS_REWARD_MNEMONIC,
+      "",
+      `The genesis reward is sent to index 0 and starts with ${(GENESIS_REWARD_AMOUNT / ATTO_XL1_PER_XL1).toString()} XL1.`,
+      "",
+      `Genesis reward wallet accounts from ${DEFAULT_WALLET_PATH}:`,
+      "",
+      report.insecureGenesisRewardAccounts.map((account) => formatGenesisRewardAccount(account)).join("\n\n")
+    ].join("\n"));
+  }
+  return sections.join("\n\n");
+}
+__name(formatWalletReport, "formatWalletReport");
+async function resolveGenesisRewardAddress(config) {
+  if (config.chain.genesisRewardAddress) return config.chain.genesisRewardAddress;
+  const wallet = await generateXyoBaseWalletFromPhrase(INSECURE_GENESIS_REWARD_MNEMONIC);
+  const account = await wallet.derivePath("0");
+  return account.address;
+}
+__name(resolveGenesisRewardAddress, "resolveGenesisRewardAddress");
+async function resolveWalletForActor(actorName, mnemonic, accountIndex) {
+  const fromReport = activeWalletReport ? actorName === ROOT_WALLET_RUNTIME_ID ? activeWalletReport.sharedAccounts.find((account) => account.accountIndex === 0) : activeWalletReport.actorSpecificAccounts.find((account) => account.actorName === actorName) ?? activeWalletReport.sharedAccounts.find((account) => account.actorName === actorName || account.label.split(", ").includes(getAccountLabel(actorName))) : void 0;
+  const resolvedMnemonic = fromReport?.mnemonic ?? mnemonic ?? BUILT_IN_DEV_MNEMONIC;
+  const resolvedAccountIndex = fromReport?.accountIndex ?? accountIndex ?? 0;
+  const wallet = await generateXyoBaseWalletFromPhrase(resolvedMnemonic);
+  return await wallet.derivePath(`${resolvedAccountIndex}`);
+}
+__name(resolveWalletForActor, "resolveWalletForActor");
+
+// src/shared/init/initActorAccount.ts
 var actorAccountSingletons = {};
 async function initActorAccount({ config, logger }) {
   const actorName = config.name;
   if (isDefined(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
-  let walletPhrase = config.mnemonic;
-  if (isUndefined(walletPhrase)) {
-    logger?.warn(`[${actorName}] No wallet mnemonic specified!`);
-    const randomMnemonic = HDWallet.generateMnemonic();
-    logger?.warn(`[${actorName}] Using randomly generated mnemonic:
-    
-${randomMnemonic}
-      
-    `);
-    walletPhrase = randomMnemonic;
-  }
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  const accountIndex = "accountIndex" in config && typeof config.accountIndex === "number" ? config.accountIndex : void 0;
+  const account = await resolveWalletForActor(actorName, config.mnemonic, accountIndex);
+  logger?.debug(`[${actorName}] Using wallet address ${account.address}`);
   actorAccountSingletons[actorName] = account;
   return actorAccountSingletons[actorName];
 }
@@ -460,28 +730,18 @@ __name(initActorAccount, "initActorAccount");
 
 // src/shared/init/initActorSeedPhrase.ts
 import { assertEx, isString } from "@xylabs/sdk-js";
-import { HDWallet as HDWallet2 } from "@xyo-network/sdk-js";
 async function initActorSeedPhrase(context, bios) {
   const { logger, config } = context;
   const walletKind = config.name;
-  const storedSeedPhrase = await bios.seedPhraseStore.get(walletKind);
-  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`);
-  const { mnemonic } = config;
-  if (isString(storedSeedPhrase) && isString(mnemonic)) {
-    logger?.warn("[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.");
-    await bios.seedPhraseStore.set(walletKind, mnemonic);
-  } else {
-    let seedPhrase;
-    if (isString(mnemonic)) {
-      seedPhrase = mnemonic;
-    } else {
-      seedPhrase = HDWallet2.generateMnemonic();
-      logger?.log("[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
-      logger?.log(`[API] Mnemonic: ${seedPhrase}`);
-    }
-    await bios.seedPhraseStore.set(walletKind, seedPhrase);
-  }
-  return assertEx(await bios.seedPhraseStore.get(walletKind), () => "Unable to acquire mnemonic from bios");
+  void bios;
+  const report = getResolvedWalletReport();
+  const account = config.name === ROOT_WALLET_RUNTIME_ID ? report?.sharedAccounts.find((entry) => entry.accountIndex === 0) : report?.actorSpecificAccounts.find((entry) => entry.actorName === config.name);
+  if (isString(account?.mnemonic)) return account.mnemonic;
+  if (isString(report?.root.mnemonic)) return report.root.mnemonic;
+  if (isString(config.mnemonic)) return config.mnemonic;
+  const fallback = getBuiltInDevMnemonic();
+  logger?.debug(`[${walletKind}] Falling back to built-in development mnemonic`);
+  return assertEx(fallback, () => "Unable to resolve mnemonic");
 }
 __name(initActorSeedPhrase, "initActorSeedPhrase");
 
@@ -535,13 +795,10 @@ function initStatusReporter({ logger }) {
 __name(initStatusReporter, "initStatusReporter");
 
 // src/shared/init/initWallet.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet3 } from "@xyo-network/sdk-js";
 async function initActorWallet(context, mnemonic) {
-  const bios = await boot();
-  const seedPhrase = isDefined2(mnemonic) ? mnemonic : await initActorSeedPhrase(context, bios);
-  return await HDWallet3.fromPhrase(seedPhrase);
+  const actorName = context.config.name === ROOT_WALLET_RUNTIME_ID ? ROOT_WALLET_RUNTIME_ID : context.config.name;
+  const accountIndex = "accountIndex" in context.config && typeof context.config.accountIndex === "number" ? context.config.accountIndex : void 0;
+  return await resolveWalletForActor(actorName, mnemonic ?? context.config.mnemonic, accountIndex);
 }
 __name(initActorWallet, "initActorWallet");
 
@@ -642,20 +899,25 @@ __name(rootLocatorFromConfig, "rootLocatorFromConfig");
 export {
   ApiConfigContext,
   ApiConfigZod,
+  BUILT_IN_DEV_MNEMONIC,
   BasisPointsZod,
   BridgeConfigContext,
   BridgeConfigZod,
   BridgeSettingsZod,
   DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL,
   DefaultServiceProvider,
+  GENESIS_REWARD_AMOUNT,
   GenericHost,
+  INSECURE_GENESIS_REWARD_MNEMONIC,
   MempoolConfigContext,
   MempoolConfigZod,
   Orchestrator,
   ProducerConfigContext,
   ProducerConfigZod,
+  ROOT_WALLET_RUNTIME_ID,
   RewardRedemptionConfigContext,
   RewardRedemptionConfigZod,
+  SHARED_ACCOUNT_REPORT_COUNT,
   ServiceLifetime,
   ValidatorActor,
   ValidatorConfigContext,
@@ -675,13 +937,20 @@ export {
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
   buildTelemetryConfig,
+  clearResolvedWalletReport,
   createProducerChainStakeIntentBlock,
+  formatWalletReport,
+  getBuiltInDevMnemonic,
+  getInsecureGenesisRewardMnemonic,
+  getReservedActorIndex,
+  getResolvedWalletReport,
   initActorAccount,
   initActorSeedPhrase,
   initActorWallet,
   initBridgedArchivistModule,
   initBridgedModule,
   initStatusReporter,
+  initializeResolvedWalletReport,
   isApiConfig,
   isApiConfigContext,
   isBridgeConfig,
@@ -695,6 +964,11 @@ export {
   isValidatorConfig,
   isValidatorConfigContext,
   mergeConfig,
+  resolveActorWallet,
+  resolveGenesisRewardAddress,
+  resolveRootWallet,
+  resolveWalletForActor,
+  resolveWalletReport,
   rootLocatorFromConfig,
   toApiConfig,
   toApiConfigContext,