@xyo-network/chain-orchestration 1.20.22 → 1.20.24

package/dist/browser/index.mjs

@@ -96,24 +96,13 @@ __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 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, {
+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"
@@ -132,7 +121,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 globalRegistry3, z as z3 } from "zod";
+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");
@@ -141,84 +130,83 @@ 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 = z3.coerce.number().int().nonnegative().max(1e4);
+var BasisPointsZod = z2.coerce.number().int().nonnegative().max(1e4);
 var BridgeConfigZod = HostActorConfigZod2.extend({
-  accountIndex: ActorAccountIndexZod("bridge.accountIndex"),
-  escrowAddress: AddressZod.optional().register(globalRegistry3, {
+  escrowAddress: AddressZod.optional().register(globalRegistry2, {
     description: "Address to which bridge escrow will be sent",
     title: "bridge.escrowAddress",
     type: "string"
   }),
-  feesAddress: AddressZod.optional().register(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  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: z3.string().default("localhost").register(globalRegistry3, {
+  redisHost: z2.string().default("localhost").register(globalRegistry2, {
     default: "localhost",
     description: "Host for the Bridge Redis instance",
     title: "bridge.redisHost",
     type: "string"
   }),
-  redisPort: z3.coerce.number().int().positive().default(6379).register(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  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(globalRegistry3, {
+  xl1ChainId: HexZod.optional().register(globalRegistry2, {
     description: "XL1 chain id used for bridging",
     title: "bridge.xl1ChainId",
     type: "string"
   }),
-  xl1TokenAddress: HexZod.optional().register(globalRegistry3, {
+  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
     description: "XL1 token address used for bridging",
     title: "bridge.xl1TokenAddress",
     type: "string"
@@ -248,12 +236,11 @@ var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigCo
 
 // src/shared/config/actors/Finalizer.ts
 import { AddressZod as AddressZod2, 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 { z as z4 } from "zod";
+import { BaseConfigContextZod as BaseConfigContextZod3, DEFAULT_MIN_CANDIDATES, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
+import { z as z3 } from "zod";
 var FinalizerConfigZod = HostActorConfigZod3.extend({
-  accountIndex: ActorAccountIndexZod("finalizer.accountIndex"),
-  allowedProducers: z4.array(AddressZod2).optional(),
-  minCandidates: z4.number().int().min(0).default(1)
+  allowedProducers: z3.array(AddressZod2).optional(),
+  minCandidates: z3.number().int().min(0).default(DEFAULT_MIN_CANDIDATES)
 });
 var isFinalizerConfig = zodIsFactory3(FinalizerConfigZod);
 var asFinalizerConfig = zodAsFactory3(FinalizerConfigZod, "asFinalizerConfig");
@@ -268,14 +255,13 @@ var toFinalizerConfigContext = zodToFactory3(FinalizerConfigContext, "toFinalize
 // src/shared/config/actors/Mempool.ts
 import { zodAsFactory as zodAsFactory4, zodIsFactory as zodIsFactory4, zodToFactory as zodToFactory4 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod4, HostActorConfigZod as HostActorConfigZod4 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+import { globalRegistry as globalRegistry3, z as z4 } from "zod";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
 var MempoolConfigZod = HostActorConfigZod4.extend({
-  accountIndex: ActorAccountIndexZod("mempool.accountIndex"),
-  enabled: z5.union([
-    z5.string(),
-    z5.boolean()
+  enabled: z4.union([
+    z4.string(),
+    z4.boolean()
   ]).default("false").transform((val, ctx) => {
     if (typeof val === "boolean") return val;
     const normalized = val.toLowerCase().trim();
@@ -296,19 +282,19 @@ var MempoolConfigZod = HostActorConfigZod4.extend({
       expected: "boolean",
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
-    return z5.NEVER;
-  }).register(globalRegistry4, {
+    return z4.NEVER;
+  }).register(globalRegistry3, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  blockPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry4, {
+  blockPruneInterval: z4.coerce.number().default(DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending block prune attempts",
     title: "mempool.blockPruneInterval",
     type: "number"
   }),
-  transactionPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry4, {
+  transactionPruneInterval: z4.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending transaction prune attempts",
     title: "mempool.transactionPruneInterval",
     type: "number"
@@ -327,43 +313,42 @@ var toMempoolConfigContext = zodToFactory4(MempoolConfigContext, "toMempoolConfi
 // src/shared/config/actors/Producer.ts
 import { AddressZod as AddressZod3, asAddress, zodAsFactory as zodAsFactory5, zodIsFactory as zodIsFactory5, zodToFactory as zodToFactory5 } from "@xylabs/sdk-js";
 import { ActorConfigZod, BaseConfigContextZod as BaseConfigContextZod5 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry5, z as z6 } from "zod";
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
-var ProducerConfigZod = ActorConfigZod.extend(z6.object({
-  accountIndex: ActorAccountIndexZod("producer.accountIndex"),
-  allowlist: z6.preprocess((val) => {
+var ProducerConfigZod = ActorConfigZod.extend(z5.object({
+  allowlist: z5.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z6.array(AddressZod3).optional().register(globalRegistry5, {
+  }, z5.array(AddressZod3).optional().register(globalRegistry4, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   })),
-  blockProductionCheckInterval: z6.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry5, {
+  blockProductionCheckInterval: z5.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
     description: "The interval time (in milliseconds) between block production attempts",
     title: "producer.blockProductionCheckInterval",
     type: "number"
   }),
-  disableIntentRedeclaration: z6.boolean().optional().register(globalRegistry5, {
+  disableIntentRedeclaration: z5.boolean().optional().register(globalRegistry4, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
-  heartbeatInterval: z6.coerce.number().default(36e5).register(globalRegistry5, {
+  heartbeatInterval: z5.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: z6.coerce.number().default(1).register(globalRegistry5, {
+  minStake: z5.coerce.number().default(1).register(globalRegistry4, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z6.string().optional().register(globalRegistry5, {
+  rewardAddress: z5.string().optional().register(globalRegistry4, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
@@ -382,9 +367,7 @@ var toProducerConfigContext = zodToFactory5(ProducerConfigContext, "toProducerCo
 // src/shared/config/actors/RewardRedemption.ts
 import { 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";
-var RewardRedemptionConfigZod = HostActorConfigZod5.extend({
-  accountIndex: ActorAccountIndexZod("rewardRedemption.accountIndex")
-});
+var RewardRedemptionConfigZod = HostActorConfigZod5.extend({});
 var isRewardRedemptionConfig = zodIsFactory6(RewardRedemptionConfigZod);
 var asRewardRedemptionConfig = zodAsFactory6(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
 var toRewardRedemptionConfig = zodToFactory6(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
@@ -463,22 +446,23 @@ var ServiceLifetime = {
 import { isDefined } from "@xylabs/sdk-js";
 
 // src/shared/init/walletResolution.ts
+import { HDWallet } from "@xyo-network/sdk-js";
 import { DEFAULT_WALLET_PATH, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+import { HDNodeWallet, Mnemonic } from "ethers";
+var DEFAULT_ACTOR_ACCOUNT_PATH = {
+  api: "3",
+  bridge: "1",
+  finalizer: "5",
+  mempool: "4",
+  producer: "0",
+  rewardRedemption: "2"
+};
 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,
-  finalizer: 6,
-  mempool: 5,
-  producer: 1,
-  rewardRedemption: 3
-};
 var ACTOR_LABELS = {
   [ROOT_WALLET_RUNTIME_ID]: "root/local-node",
   api: "api",
@@ -497,10 +481,30 @@ function clearResolvedWalletReport() {
   activeWalletReport = void 0;
 }
 __name(clearResolvedWalletReport, "clearResolvedWalletReport");
-function getReservedActorIndex(actorName) {
-  return RESERVED_ACTOR_INDEX[actorName] ?? 0;
+function resolveActorAccountPath(actorName, actorConfig) {
+  if (actorConfig?.accountPath !== void 0) return actorConfig.accountPath;
+  return DEFAULT_ACTOR_ACCOUNT_PATH[actorName] ?? "0";
 }
-__name(getReservedActorIndex, "getReservedActorIndex");
+__name(resolveActorAccountPath, "resolveActorAccountPath");
+function isAbsoluteAccountPath(accountPath) {
+  return accountPath.startsWith("m/");
+}
+__name(isAbsoluteAccountPath, "isAbsoluteAccountPath");
+function expandAccountPath(accountPath, basePath = DEFAULT_WALLET_PATH) {
+  return isAbsoluteAccountPath(accountPath) ? accountPath : `${basePath}/${accountPath}`;
+}
+__name(expandAccountPath, "expandAccountPath");
+async function deriveWalletAtPath(mnemonic, accountPath) {
+  if (isAbsoluteAccountPath(accountPath)) {
+    const seed = Mnemonic.fromPhrase(mnemonic).computeSeed();
+    const rootNode = HDNodeWallet.fromSeed(seed);
+    const derivedNode = rootNode.derivePath(accountPath);
+    return await HDWallet.createFromNode(derivedNode);
+  }
+  const baseWallet = await generateXyoBaseWalletFromPhrase(mnemonic);
+  return await baseWallet.derivePath(accountPath);
+}
+__name(deriveWalletAtPath, "deriveWalletAtPath");
 function getBuiltInDevMnemonic() {
   return BUILT_IN_DEV_MNEMONIC;
 }
@@ -522,83 +526,115 @@ function resolveRootWallet(configuration) {
   };
 }
 __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}`);
+async function resolveWalletMetadata({ accountPath, actorName, mnemonic, mnemonicKind }) {
+  const account = await deriveWalletAtPath(mnemonic, accountPath);
   return {
-    accountIndex,
+    accountPath,
     actorName,
     address: account.address,
-    derivationPath,
+    derivationPath: expandAccountPath(accountPath),
     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),
+  return await resolveWalletMetadata({
+    accountPath: resolveActorAccountPath(actorName, actorConfig),
     actorName,
     mnemonic: root.mnemonic,
-    mnemonicKind: root.mnemonicKind,
-    source: "root"
+    mnemonicKind: root.mnemonicKind
   });
 }
 __name(resolveActorWallet, "resolveActorWallet");
+var ActorMnemonicNotAllowedError = class extends Error {
+  static {
+    __name(this, "ActorMnemonicNotAllowedError");
+  }
+  actors;
+  constructor(actors) {
+    super([
+      `Per-actor mnemonics are no longer allowed (found on: ${actors.join(", ")}).`,
+      'Move the mnemonic to the root (XL1_MNEMONIC, --mnemonic, or config file "xl1.mnemonic") and give each actor a distinct accountPath.'
+    ].join("\n"));
+    this.name = "ActorMnemonicNotAllowedError";
+    this.actors = actors;
+  }
+};
+function assertNoActorMnemonics(configuration) {
+  const offenders = configuration.actors.filter((actor) => typeof actor.mnemonic === "string").map((actor) => actor.name);
+  if (offenders.length > 0) throw new ActorMnemonicNotAllowedError(offenders);
+}
+__name(assertNoActorMnemonics, "assertNoActorMnemonics");
+var DerivationPathCollisionError = class extends Error {
+  static {
+    __name(this, "DerivationPathCollisionError");
+  }
+  collisions;
+  constructor(collisions) {
+    const lines = Object.entries(collisions).map(([path, actors]) => `  - ${actors.join(", ")} \u2192 ${path}`);
+    super([
+      "Two or more actors resolve to the same wallet derivation path:",
+      ...lines,
+      "Change each actor's accountPath so every actor has a distinct path."
+    ].join("\n"));
+    this.name = "DerivationPathCollisionError";
+    this.collisions = collisions;
+  }
+};
+function detectDerivationPathCollisions(requestedActors, configuration) {
+  const actorConfigMap = new Map(configuration.actors.map((actor) => [
+    actor.name,
+    actor
+  ]));
+  const bucketsByPath = /* @__PURE__ */ new Map();
+  for (const actorName of requestedActors) {
+    const accountPath = resolveActorAccountPath(actorName, actorConfigMap.get(actorName));
+    const fullPath = expandAccountPath(accountPath);
+    const bucket = bucketsByPath.get(fullPath) ?? [];
+    bucket.push(actorName);
+    bucketsByPath.set(fullPath, bucket);
+  }
+  const collisions = {};
+  for (const [path, actors] of bucketsByPath) {
+    if (actors.length > 1) collisions[path] = actors;
+  }
+  if (Object.keys(collisions).length === 0) return void 0;
+  return new DerivationPathCollisionError(collisions);
+}
+__name(detectDerivationPathCollisions, "detectDerivationPathCollisions");
 async function resolveWalletReport(requestedActors, configuration) {
   const root = resolveRootWallet(configuration);
   const actorConfigMap = new Map(configuration.actors.map((actor) => [
     actor.name,
     actor
   ]));
-  const isRootRequired = requestedActors.some((actorName) => !actorConfigMap.get(actorName)?.mnemonic);
   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)
-      ]
-    ]
-  ]);
+  const labelMap = /* @__PURE__ */ new Map();
   for (const actor of resolvedActors) {
-    if (actor.source !== "root") continue;
-    const labels = labelMap.get(actor.accountIndex) ?? [];
+    const labels = labelMap.get(actor.derivationPath) ?? [];
     labels.push(actor.label);
-    labelMap.set(actor.accountIndex, labels);
+    labelMap.set(actor.derivationPath, labels);
   }
   const sharedAccounts = await Promise.all(Array.from({
     length: SHARED_ACCOUNT_REPORT_COUNT
-  }, (_, index) => index).map(async (accountIndex) => {
+  }, (_, index) => index).map(async (sharedIndex) => {
     const account = await resolveWalletMetadata({
-      accountIndex,
+      accountPath: `${sharedIndex}`,
       actorName: ROOT_WALLET_RUNTIME_ID,
       mnemonic: root.mnemonic,
-      mnemonicKind: root.mnemonicKind,
-      source: "root"
+      mnemonicKind: root.mnemonicKind
     });
-    const labels = labelMap.get(accountIndex);
+    const labels = labelMap.get(account.derivationPath);
     return {
       ...account,
-      label: labels?.join(", ") ?? `shared[${accountIndex}]`
+      label: labels?.join(", ") ?? `shared[${sharedIndex}]`
     };
   }));
   return {
-    actorSpecificAccounts: resolvedActors.filter((actor) => actor.source === "actor"),
-    isRootRequired,
     requestedActors: [
       ...requestedActors
     ],
@@ -610,17 +646,16 @@ __name(resolveWalletReport, "resolveWalletReport");
 async function buildInsecureGenesisRewardAccounts() {
   const accounts = await Promise.all(Array.from({
     length: SHARED_ACCOUNT_REPORT_COUNT
-  }, (_, index) => index).map(async (accountIndex) => {
+  }, (_, index) => index).map(async (sharedIndex) => {
     const account = await resolveWalletMetadata({
-      accountIndex,
+      accountPath: `${sharedIndex}`,
       actorName: "genesisReward",
       mnemonic: INSECURE_GENESIS_REWARD_MNEMONIC,
-      mnemonicKind: "configured-actor",
-      source: "actor"
+      mnemonicKind: "insecure-genesis-reward"
     });
     return {
       ...account,
-      label: accountIndex === 0 ? "genesisRewardAddress" : `genesisReward[${accountIndex}]`
+      label: sharedIndex === 0 ? "genesisRewardAddress" : `genesisReward[${sharedIndex}]`
     };
   }));
   return accounts;
@@ -637,7 +672,7 @@ function getResolvedWalletReport() {
 __name(getResolvedWalletReport, "getResolvedWalletReport");
 function formatSharedAccount(account, showPrivateKey) {
   const lines = [
-    `[${account.accountIndex}] ${account.label}`,
+    `[${account.accountPath}] ${account.label}`,
     `source: ${account.mnemonicKind === "built-in-dev" ? "built-in dev mnemonic" : "configured root mnemonic"}`,
     `path: ${account.derivationPath}`,
     `address: ${account.address}`
@@ -646,19 +681,10 @@ function formatSharedAccount(account, showPrivateKey) {
   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;
+  const balance = account.accountPath === "0" ? GENESIS_REWARD_AMOUNT / ATTO_XL1_PER_XL1 : 0n;
   return [
-    `[${account.accountIndex}] ${account.label}`,
+    `[${account.accountPath}] ${account.label}`,
     `path: ${account.derivationPath}`,
     `address: ${account.address}`,
     `privateKey: ${account.privateKey ?? "unavailable"}`,
@@ -668,13 +694,8 @@ function formatGenesisRewardAccount(account) {
 __name(formatGenesisRewardAccount, "formatGenesisRewardAccount");
 function formatWalletReport(report) {
   const sections = [];
-  const showRootSection = report.isRootRequired || report.root.isConfigured;
-  const showSecrets = report.root.isBuiltInDevMnemonic && showRootSection;
-  if (showRootSection) {
-    sections.push(showSecrets ? "Development wallet detected." : "Wallet summary");
-  } else {
-    sections.push("Wallet summary (root wallet not required \u2014 every requested actor has its own mnemonic)");
-  }
+  const showSecrets = report.root.isBuiltInDevMnemonic;
+  sections.push(showSecrets ? "Development wallet detected." : "Wallet summary");
   if (showSecrets) {
     sections.push([
       "DEVELOPMENT WALLET WARNING",
@@ -688,20 +709,11 @@ function formatWalletReport(report) {
       report.root.mnemonic
     ].join("\n"));
   }
-  if (showRootSection) {
-    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"));
-  }
+  sections.push([
+    `Shared wallet accounts from ${report.root.basePath}:`,
+    "",
+    report.sharedAccounts.map((account) => formatSharedAccount(account, showSecrets)).join("\n\n")
+  ].join("\n"));
   return sections.join("\n\n");
 }
 __name(formatWalletReport, "formatWalletReport");
@@ -731,12 +743,11 @@ async function resolveGenesisRewardAddress(config) {
   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}`);
+async function resolveWalletForActor(actorName, accountPath) {
+  const report = activeWalletReport;
+  const mnemonic = report?.root.mnemonic ?? BUILT_IN_DEV_MNEMONIC;
+  const resolvedAccountPath = accountPath ?? resolveActorAccountPath(actorName);
+  return await deriveWalletAtPath(mnemonic, resolvedAccountPath);
 }
 __name(resolveWalletForActor, "resolveWalletForActor");
 
@@ -745,8 +756,8 @@ var actorAccountSingletons = {};
 async function initActorAccount({ config, logger }) {
   const actorName = config.name;
   if (isDefined(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName];
-  const accountIndex = "accountIndex" in config && typeof config.accountIndex === "number" ? config.accountIndex : void 0;
-  const account = await resolveWalletForActor(actorName, config.mnemonic, accountIndex);
+  const accountPath = typeof config.accountPath === "string" ? config.accountPath : void 0;
+  const account = await resolveWalletForActor(actorName, accountPath);
   logger?.debug(`[${actorName}] Using wallet address ${account.address}`);
   actorAccountSingletons[actorName] = account;
   return actorAccountSingletons[actorName];
@@ -760,10 +771,7 @@ async function initActorSeedPhrase(context, bios) {
   const walletKind = config.name;
   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");
@@ -820,10 +828,10 @@ function initStatusReporter({ logger }) {
 __name(initStatusReporter, "initStatusReporter");
 
 // src/shared/init/initWallet.ts
-async function initActorWallet(context, mnemonic) {
-  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);
+async function initActorWallet(context) {
+  const actorName = context.config.name;
+  const accountPath = typeof context.config.accountPath === "string" ? context.config.accountPath : void 0;
+  return await resolveWalletForActor(actorName, accountPath);
 }
 __name(initActorWallet, "initActorWallet");
 
@@ -957,6 +965,7 @@ async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
 }
 __name(rootLocatorFromConfig, "rootLocatorFromConfig");
 export {
+  ActorMnemonicNotAllowedError,
   ApiConfigContext,
   ApiConfigZod,
   BUILT_IN_DEV_MNEMONIC,
@@ -964,10 +973,12 @@ export {
   BridgeConfigContext,
   BridgeConfigZod,
   BridgeSettingsZod,
+  DEFAULT_ACTOR_ACCOUNT_PATH,
   DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL,
   DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL,
   DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL,
   DefaultServiceProvider,
+  DerivationPathCollisionError,
   FinalizerActor,
   FinalizerConfigContext,
   FinalizerConfigZod,
@@ -998,17 +1009,19 @@ export {
   asProducerConfigContext,
   asRewardRedemptionConfig,
   asRewardRedemptionConfigContext,
+  assertNoActorMnemonics,
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
   buildInsecureGenesisRewardAccounts,
   buildTelemetryConfig,
   clearResolvedWalletReport,
   createProducerChainStakeIntentBlock,
+  detectDerivationPathCollisions,
+  expandAccountPath,
   formatInsecureGenesisRewardWarning,
   formatWalletReport,
   getBuiltInDevMnemonic,
   getInsecureGenesisRewardMnemonic,
-  getReservedActorIndex,
   getResolvedWalletReport,
   initActorAccount,
   initActorSeedPhrase,
@@ -1017,6 +1030,7 @@ export {
   initBridgedModule,
   initStatusReporter,
   initializeResolvedWalletReport,
+  isAbsoluteAccountPath,
   isApiConfig,
   isApiConfigContext,
   isBridgeConfig,
@@ -1030,6 +1044,7 @@ export {
   isRewardRedemptionConfig,
   isRewardRedemptionConfigContext,
   mergeConfig,
+  resolveActorAccountPath,
   resolveActorWallet,
   resolveGenesisRewardAddress,
   resolveRootWallet,