@xyo-network/chain-orchestration 1.20.21 → 1.20.23

package/dist/node/index.mjs

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/shared/actor/ValidatorActor.ts
+// src/shared/actor/FinalizerActor.ts
 import { creatable } from "@xylabs/sdk-js";
 import { processPendingBlocks } from "@xyo-network/chain-sdk";
 import { ActorV3, BlockValidationViewerMoniker, BlockViewerMoniker, DeadLetterQueueRunnerMoniker, FinalizationRunnerMoniker, MempoolViewerMoniker } from "@xyo-network/xl1-sdk";
@@ -12,16 +12,14 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
-var ValidatorActor = class extends ActorV3 {
+var FinalizerActor = class extends ActorV3 {
   static {
-    __name(this, "ValidatorActor");
+    __name(this, "FinalizerActor");
   }
   _blockValidationViewer;
   _blockViewer;
   _deadLetterQueueRunner;
   _finalizationRunner;
-  _lastValidatedBlock;
-  _lastValidatedBlockHash;
   _mempoolViewer;
   get allowedProducers() {
     return this.params.config.allowedProducers ?? [];
@@ -51,9 +49,9 @@ var ValidatorActor = class extends ActorV3 {
   }
   async startHandler() {
     await super.startHandler();
-    this.registerTimer("ValidatorActor", async () => {
+    this.registerTimer("FinalizerActor", async () => {
       await this.spanAsync("processPendingBlocks", async () => {
-        this.logger?.debug("ValidatorActor: Processing pending blocks...");
+        this.logger?.debug("FinalizerActor: Processing pending blocks...");
         await processPendingBlocks({
           blockValidationViewer: this.blockValidationViewer,
           context: this.context,
@@ -72,9 +70,9 @@ var ValidatorActor = class extends ActorV3 {
     }, 2e3, 500);
   }
 };
-ValidatorActor = _ts_decorate([
+FinalizerActor = _ts_decorate([
   creatable()
-], ValidatorActor);
+], FinalizerActor);
 
 // src/shared/buildTelemetryConfig.ts
 function buildTelemetryConfig(config, serviceName, serviceVersion, defaultMetricsScrapePort = 9464) {
@@ -98,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"
@@ -134,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");
@@ -143,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,14 +234,31 @@ var isBridgeConfigContext = zodIsFactory2(BridgeConfigContext);
 var asBridgeConfigContext = zodAsFactory2(BridgeConfigContext, "asBridgeConfigContext");
 var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigContext");
 
+// 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, DEFAULT_MIN_CANDIDATES, HostActorConfigZod as HostActorConfigZod3 } from "@xyo-network/xl1-sdk";
+import { z as z3 } from "zod";
+var FinalizerConfigZod = HostActorConfigZod3.extend({
+  allowedProducers: z3.array(AddressZod2).optional(),
+  minCandidates: z3.number().int().min(0).default(DEFAULT_MIN_CANDIDATES)
+});
+var isFinalizerConfig = zodIsFactory3(FinalizerConfigZod);
+var asFinalizerConfig = zodAsFactory3(FinalizerConfigZod, "asFinalizerConfig");
+var toFinalizerConfig = zodToFactory3(FinalizerConfigZod, "toFinalizerConfig");
+var FinalizerConfigContext = BaseConfigContextZod3.extend({
+  config: FinalizerConfigZod
+});
+var isFinalizerConfigContext = zodIsFactory3(FinalizerConfigContext);
+var asFinalizerConfigContext = zodAsFactory3(FinalizerConfigContext, "asFinalizerConfigContext");
+var toFinalizerConfigContext = zodToFactory3(FinalizerConfigContext, "toFinalizerConfigContext");
+
 // 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 globalRegistry4, z as z4 } from "zod";
+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 globalRegistry3, z as z4 } from "zod";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
-var MempoolConfigZod = HostActorConfigZod3.extend({
-  accountIndex: ActorAccountIndexZod("mempool.accountIndex"),
+var MempoolConfigZod = HostActorConfigZod4.extend({
   enabled: z4.union([
     z4.string(),
     z4.boolean()
@@ -280,122 +283,100 @@ var MempoolConfigZod = HostActorConfigZod3.extend({
       message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
     });
     return z4.NEVER;
-  }).register(globalRegistry4, {
+  }).register(globalRegistry3, {
     default: "false",
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  blockPruneInterval: z4.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: z4.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"
   })
 });
-var isMempoolConfig = zodIsFactory3(MempoolConfigZod);
-var asMempoolConfig = zodAsFactory3(MempoolConfigZod, "asMempoolConfig");
-var toMempoolConfig = zodToFactory3(MempoolConfigZod, "toMempoolConfig");
-var MempoolConfigContext = BaseConfigContextZod3.extend({
+var isMempoolConfig = zodIsFactory4(MempoolConfigZod);
+var asMempoolConfig = zodAsFactory4(MempoolConfigZod, "asMempoolConfig");
+var toMempoolConfig = zodToFactory4(MempoolConfigZod, "toMempoolConfig");
+var MempoolConfigContext = BaseConfigContextZod4.extend({
   config: MempoolConfigZod
 });
-var isMempoolConfigContext = zodIsFactory3(MempoolConfigContext);
-var asMempoolConfigContext = zodAsFactory3(MempoolConfigContext, "asMempoolConfigContext");
-var toMempoolConfigContext = zodToFactory3(MempoolConfigContext, "toMempoolConfigContext");
+var isMempoolConfigContext = zodIsFactory4(MempoolConfigContext);
+var asMempoolConfigContext = zodAsFactory4(MempoolConfigContext, "asMempoolConfigContext");
+var toMempoolConfigContext = zodToFactory4(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 globalRegistry5, z as z5 } from "zod";
+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 globalRegistry4, z as z5 } from "zod";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
 var ProducerConfigZod = ActorConfigZod.extend(z5.object({
-  accountIndex: ActorAccountIndexZod("producer.accountIndex"),
   allowlist: z5.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z5.array(AddressZod2).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: z5.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: z5.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: z5.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: z5.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: z5.string().optional().register(globalRegistry5, {
+  rewardAddress: z5.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({
+var isProducerConfig = zodIsFactory5(ProducerConfigZod);
+var asProducerConfig = zodAsFactory5(ProducerConfigZod, "asProducerConfig");
+var toProducerConfig = zodToFactory5(ProducerConfigZod, "toProducerConfig");
+var ProducerConfigContext = BaseConfigContextZod5.extend({
   config: ProducerConfigZod
 });
-var isProducerConfigContext = zodIsFactory4(ProducerConfigContext);
-var asProducerConfigContext = zodAsFactory4(ProducerConfigContext, "asProducerConfigContext");
-var toProducerConfigContext = zodToFactory4(ProducerConfigContext, "toProducerConfigContext");
+var isProducerConfigContext = zodIsFactory5(ProducerConfigContext);
+var asProducerConfigContext = zodAsFactory5(ProducerConfigContext, "asProducerConfigContext");
+var toProducerConfigContext = zodToFactory5(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({
-  accountIndex: ActorAccountIndexZod("rewardRedemption.accountIndex")
-});
-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/actors/Validator.ts
-import { AddressZod as AddressZod3, zodAsFactory as zodAsFactory6, zodIsFactory as zodIsFactory6, zodToFactory as zodToFactory6 } from "@xylabs/sdk-js";
+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";
-import { z as z6 } from "zod";
-var ValidatorConfigZod = HostActorConfigZod5.extend({
-  accountIndex: ActorAccountIndexZod("validator.accountIndex"),
-  allowedProducers: z6.array(AddressZod3).optional(),
-  minCandidates: z6.number().int().min(0).default(1)
-});
-var isValidatorConfig = zodIsFactory6(ValidatorConfigZod);
-var asValidatorConfig = zodAsFactory6(ValidatorConfigZod, "asValidatorConfig");
-var toValidatorConfig = zodToFactory6(ValidatorConfigZod, "toValidatorConfig");
-var ValidatorConfigContext = BaseConfigContextZod6.extend({
-  config: ValidatorConfigZod
+var RewardRedemptionConfigZod = HostActorConfigZod5.extend({});
+var isRewardRedemptionConfig = zodIsFactory6(RewardRedemptionConfigZod);
+var asRewardRedemptionConfig = zodAsFactory6(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
+var toRewardRedemptionConfig = zodToFactory6(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
+var RewardRedemptionConfigContext = BaseConfigContextZod6.extend({
+  config: RewardRedemptionConfigZod
 });
-var isValidatorConfigContext = zodIsFactory6(ValidatorConfigContext);
-var asValidatorConfigContext = zodAsFactory6(ValidatorConfigContext, "asValidatorConfigContext");
-var toValidatorConfigContext = zodToFactory6(ValidatorConfigContext, "toValidatorConfigContext");
+var isRewardRedemptionConfigContext = zodIsFactory6(RewardRedemptionConfigContext);
+var asRewardRedemptionConfigContext = zodAsFactory6(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
+var toRewardRedemptionConfigContext = zodToFactory6(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
 
 // src/shared/config/mergeConfig.ts
 import { deepMerge } from "@xylabs/sdk-js";
@@ -465,30 +446,31 @@ 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,
-  mempool: 5,
-  producer: 1,
-  rewardRedemption: 3,
-  validator: 6
-};
 var ACTOR_LABELS = {
   [ROOT_WALLET_RUNTIME_ID]: "root/local-node",
   api: "api",
   bridge: "bridge",
+  finalizer: "finalizer",
   mempool: "mempool",
   producer: "producer",
-  rewardRedemption: "rewardRedemption",
-  validator: "validator"
+  rewardRedemption: "rewardRedemption"
 };
 var activeWalletReport;
 function getAccountLabel(actorName) {
@@ -499,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(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(getReservedActorIndex, "getReservedActorIndex");
+__name(deriveWalletAtPath, "deriveWalletAtPath");
 function getBuiltInDevMnemonic() {
   return BUILT_IN_DEV_MNEMONIC;
 }
@@ -512,52 +514,98 @@ function getInsecureGenesisRewardMnemonic() {
 }
 __name(getInsecureGenesisRewardMnemonic, "getInsecureGenesisRewardMnemonic");
 function resolveRootWallet(configuration) {
+  const isConfigured = configuration.mnemonic !== void 0;
   const mnemonic = configuration.mnemonic ?? BUILT_IN_DEV_MNEMONIC;
   const isBuiltInDevMnemonic = mnemonic === BUILT_IN_DEV_MNEMONIC;
   return {
     basePath: DEFAULT_WALLET_PATH,
     isBuiltInDevMnemonic,
+    isConfigured,
     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}`);
+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) => [
@@ -565,62 +613,54 @@ async function resolveWalletReport(requestedActors, configuration) {
     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)
-      ]
-    ]
-  ]);
+  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}]`
     };
   }));
-  const insecureGenesisRewardAccounts = configuration.chain.genesisRewardAddress ? void 0 : await Promise.all(Array.from({
+  return {
+    requestedActors: [
+      ...requestedActors
+    ],
+    root,
+    sharedAccounts
+  };
+}
+__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 {
-    actorSpecificAccounts: resolvedActors.filter((actor) => actor.source === "actor"),
-    insecureGenesisRewardAccounts,
-    requestedActors: [
-      ...requestedActors
-    ],
-    root,
-    sharedAccounts
-  };
+  return accounts;
 }
-__name(resolveWalletReport, "resolveWalletReport");
+__name(buildInsecureGenesisRewardAccounts, "buildInsecureGenesisRewardAccounts");
 async function initializeResolvedWalletReport(requestedActors, configuration) {
   activeWalletReport = await resolveWalletReport(requestedActors, configuration);
   return activeWalletReport;
@@ -632,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}`
@@ -641,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"}`,
@@ -683,34 +714,28 @@ function formatWalletReport(report) {
     "",
     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");
+function formatInsecureGenesisRewardWarning(accounts) {
+  return [
+    "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}:`,
+    "",
+    accounts.map((account) => formatGenesisRewardAccount(account)).join("\n\n")
+  ].join("\n");
+}
+__name(formatInsecureGenesisRewardWarning, "formatInsecureGenesisRewardWarning");
 async function resolveGenesisRewardAddress(config) {
   if (config.chain.genesisRewardAddress) return config.chain.genesisRewardAddress;
   const wallet = await generateXyoBaseWalletFromPhrase(INSECURE_GENESIS_REWARD_MNEMONIC);
@@ -718,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");
 
@@ -732,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];
@@ -747,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");
@@ -807,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");
 
@@ -879,6 +900,41 @@ Orchestrator = _ts_decorate2([
   creatable2()
 ], Orchestrator);
 
+// src/shared/provider/SimpleRejectedTransactionsArchivistProvider.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { AbstractCreatableProvider, creatableProvider } from "@xyo-network/xl1-sdk";
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+var RejectedTransactionsArchivistProviderMoniker = "RejectedTransactionsArchivistProvider";
+var SimpleRejectedTransactionsArchivistProvider = class _SimpleRejectedTransactionsArchivistProvider extends AbstractCreatableProvider {
+  static {
+    __name(this, "SimpleRejectedTransactionsArchivistProvider");
+  }
+  static defaultMoniker = RejectedTransactionsArchivistProviderMoniker;
+  static dependencies = [];
+  static monikers = [
+    RejectedTransactionsArchivistProviderMoniker
+  ];
+  moniker = _SimpleRejectedTransactionsArchivistProvider.defaultMoniker;
+  get archivist() {
+    return this.params.archivist;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      archivist: assertEx3(params?.archivist, () => "archivist is required")
+    };
+  }
+};
+SimpleRejectedTransactionsArchivistProvider = _ts_decorate3([
+  creatableProvider()
+], SimpleRejectedTransactionsArchivistProvider);
+
 // src/node/config/locators/basicRemoteRunnerLocator.ts
 import { isAccountInstance } from "@xyo-network/sdk-js";
 import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator, JsonRpcAccountBalanceViewer, JsonRpcXyoSigner, SimpleXyoSigner } from "@xyo-network/xl1-sdk";
@@ -957,13 +1013,13 @@ async function contextFromConfigWithoutLocator(config, logger, serviceName, serv
 __name(contextFromConfigWithoutLocator, "contextFromConfigWithoutLocator");
 
 // src/node/config/locators/localLocatorFromConfig.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
 import { validateHydratedBlock, validateHydratedBlockState } from "@xyo-network/chain-validation";
 import { BlockCumulativeBalanceValidatorFactory, ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockValidationViewer, SimpleBlockViewer, SimpleDeadLetterQueueRunner, SimpleDeadLetterQueueViewer, SimpleFinalizationRunner, SimpleFinalizationViewer, SimpleMempoolRunner, SimpleMempoolViewer, SimpleTransactionValidationViewer, SimpleTransactionViewer, SimpleWindowedBlockViewer, SimpleXyoConnectionViewer, SimpleXyoViewer, validateTransaction } from "@xyo-network/xl1-sdk";
 
 // src/node/init/initBalanceSummaryMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { MongoMap } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-sdk";
 async function initBalanceSummaryMap({ logger, config }) {
@@ -988,7 +1044,7 @@ async function initBalanceSummaryMap({ logger, config }) {
         maxEntries: 5e3
       }
     });
-    assertEx3(await result.start(), () => "Failed to start transfer summary map");
+    assertEx4(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
@@ -1050,11 +1106,11 @@ async function initEvmProvidersIfAvailable(locator) {
 __name(initEvmProvidersIfAvailable, "initEvmProvidersIfAvailable");
 
 // src/node/init/initFinalizationArchivistIfNeeded.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5 } 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) {
+async function initFinalizationArchivistIfNeeded(archivist, config, account, options = {}) {
   const configuredChainId = config.chain.id;
   const possibleHead = await findMostRecentBlock(archivist);
   if (configuredChainId && possibleHead && possibleHead.chain !== configuredChainId) {
@@ -1063,13 +1119,18 @@ async function initFinalizationArchivistIfNeeded(archivist, config, account) {
   let possibleChainId = configuredChainId;
   if (!possibleHead) {
     possibleChainId = possibleChainId ?? (await Account.random()).address;
+    if (!config.chain.genesisRewardAddress) {
+      const accounts = await buildInsecureGenesisRewardAccounts();
+      options.logger?.warn(formatInsecureGenesisRewardWarning(accounts));
+      if (options.onInsecureGenesisConfirm) await options.onInsecureGenesisConfirm();
+    }
     const genesisRewardAddress = await resolveGenesisRewardAddress(config);
     const chain = await createBootstrapHead(account, possibleChainId, asAttoXL1(GENESIS_REWARD_AMOUNT), genesisRewardAddress);
     const payloads = chain.flatMap((block) => flattenHydratedBlock(block));
     await archivist.insert(payloads);
   }
-  const head = possibleHead ?? assertEx4(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
-  const chainId = assertEx4(possibleChainId, () => "Chain ID could not be determined");
+  const head = possibleHead ?? assertEx5(await findMostRecentBlock(archivist), () => "No blocks found in chain archivist");
+  const chainId = assertEx5(possibleChainId, () => "Chain ID could not be determined");
   return [
     head,
     chainId
@@ -1096,7 +1157,7 @@ async function initFinalizedArchivist(config) {
 __name(initFinalizedArchivist, "initFinalizedArchivist");
 
 // src/node/init/initServerNode.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 import { asArchivistInstance } from "@xyo-network/sdk-js";
 
 // src/node/manifest/getLocator.ts
@@ -1423,7 +1484,7 @@ async function writableChainArchivistFromNode(node) {
 }
 __name(writableChainArchivistFromNode, "writableChainArchivistFromNode");
 async function readonlyChainArchivistFromNode(node) {
-  return assertEx5(asArchivistInstance(await node.resolve("Chain:Validated"), {
+  return assertEx6(asArchivistInstance(await node.resolve("Chain:Validated"), {
     required: true
   }));
 }
@@ -1454,7 +1515,7 @@ async function rejectedTransactionsArchivistFromNode(node) {
 __name(rejectedTransactionsArchivistFromNode, "rejectedTransactionsArchivistFromNode");
 async function initServerNode(context, wallet, providedNode) {
   const node = providedNode ?? await loadNode(context, wallet);
-  assertEx5(await node.start(), () => "Failed to start node");
+  assertEx6(await node.start(), () => "Failed to start node");
   const writableChainArchivist = await writableChainArchivistFromNode(node);
   const readonlyChainArchivist = await readonlyChainArchivistFromNode(node);
   const pendingTransactionsArchivist = await pendingTransactionsArchivistFromNode(node);
@@ -1475,7 +1536,7 @@ __name(initServerNode, "initServerNode");
 
 // src/node/init/initTransferSummaryMap.ts
 import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-sdk";
 async function initTransferSummaryMap({ logger, config }) {
@@ -1500,7 +1561,7 @@ async function initTransferSummaryMap({ logger, config }) {
         maxEntries: 5e3
       }
     });
-    assertEx6(await result.start(), () => "Failed to start transfer summary map");
+    assertEx7(await result.start(), () => "Failed to start transfer summary map");
     return result;
   } else {
     logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
@@ -1521,12 +1582,15 @@ var validateHydratedBlockStateWithCumulativeBalance = /* @__PURE__ */ __name(asy
     ...cumulativeErrors
   ];
 }, "validateHydratedBlockStateWithCumulativeBalance");
-async function localLocatorFromConfig(context, validateDepsOnRegister = false) {
-  const balancesSummaryMap = assertEx7(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
-  const transfersSummaryMap = assertEx7(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
+async function localLocatorFromConfig(context, validateDepsOnRegister = false, onInsecureGenesisConfirm) {
+  const balancesSummaryMap = assertEx8(await initBalanceSummaryMap(context), () => "Balance Summary Map not initialized");
+  const transfersSummaryMap = assertEx8(await initTransferSummaryMap(context), () => "Transfer Summary Map not initialized");
   const wallet = await initActorWallet(context);
   const { writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist, rejectedBlocksArchivist, rejectedTransactionsArchivist } = await initServerNode(context, wallet);
-  await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet);
+  await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet, {
+    logger: context.logger,
+    onInsecureGenesisConfirm
+  });
   const locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister);
   locator.registerMany([
     SimpleMempoolViewer.factory(SimpleMempoolViewer.dependencies, {
@@ -1574,6 +1638,9 @@ async function localLocatorFromConfig(context, validateDepsOnRegister = false) {
     SimpleDeadLetterQueueViewer.factory(SimpleDeadLetterQueueViewer.dependencies, {
       rejectedBlocksArchivist,
       rejectedTransactionsArchivist
+    }),
+    SimpleRejectedTransactionsArchivistProvider.factory(SimpleRejectedTransactionsArchivistProvider.dependencies, {
+      archivist: rejectedTransactionsArchivist
     })
   ]);
   return locator;
@@ -1658,9 +1725,9 @@ async function bridgeLocatorFromConfig(context, parent) {
 }
 __name(bridgeLocatorFromConfig, "bridgeLocatorFromConfig");
 
-// src/node/config/locators/actors/mempoolLocatorFromConfig.ts
+// src/node/config/locators/actors/finalizerLocatorFromConfig.ts
 import { ProviderFactoryLocator as ProviderFactoryLocator4 } from "@xyo-network/xl1-sdk";
-function mempoolLocatorFromConfig(context, parent) {
+function finalizerLocatorFromConfig(context, parent) {
   const locator = new ProviderFactoryLocator4({
     ...context,
     locator: parent
@@ -1669,16 +1736,29 @@ function mempoolLocatorFromConfig(context, parent) {
   locator.freeze();
   return locator;
 }
+__name(finalizerLocatorFromConfig, "finalizerLocatorFromConfig");
+
+// src/node/config/locators/actors/mempoolLocatorFromConfig.ts
+import { ProviderFactoryLocator as ProviderFactoryLocator5 } from "@xyo-network/xl1-sdk";
+function mempoolLocatorFromConfig(context, parent) {
+  const locator = new ProviderFactoryLocator5({
+    ...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 ProviderFactoryLocator5 } from "@xyo-network/xl1-sdk";
+import { ProviderFactoryLocator as ProviderFactoryLocator6 } from "@xyo-network/xl1-sdk";
 async function producerLocatorFromConfig(context, parent) {
   const { logger, config } = context;
   const account = await initActorAccount(context);
-  const locator = new ProviderFactoryLocator5({
+  const locator = new ProviderFactoryLocator6({
     ...context,
     locator: parent
   });
@@ -1687,10 +1767,13 @@ async function producerLocatorFromConfig(context, parent) {
   if (rewardAddress === account.address) {
     logger?.warn(`Using producer account address as reward address: ${account.address}`);
   }
+  const rejectedTransactionsProvider = await parent?.tryGetInstance(RejectedTransactionsArchivistProviderMoniker);
+  const rejectedTransactionsArchivist = rejectedTransactionsProvider?.archivist;
   locator.registerMany([
     SimpleBlockRunner.factory(SimpleBlockRunner.dependencies, {
       account,
-      rewardAddress
+      rewardAddress,
+      rejectedTransactionsArchivist
     })
   ]);
   locator.freeze();
@@ -1699,9 +1782,9 @@ async function producerLocatorFromConfig(context, parent) {
 __name(producerLocatorFromConfig, "producerLocatorFromConfig");
 
 // src/node/config/locators/actors/rewardRedemptionLocatorFromConfig.ts
-import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer4, JsonRpcBlockViewer as JsonRpcBlockViewer2, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer2, JsonRpcMempoolRunner as JsonRpcMempoolRunner2, JsonRpcMempoolViewer as JsonRpcMempoolViewer2, JsonRpcXyoRunner as JsonRpcXyoRunner2, JsonRpcXyoViewer as JsonRpcXyoViewer2, ProviderFactoryLocator as ProviderFactoryLocator6, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner3, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoRunner as SimpleXyoRunner3, SimpleXyoSigner as SimpleXyoSigner3 } from "@xyo-network/xl1-sdk";
+import { JsonRpcAccountBalanceViewer as JsonRpcAccountBalanceViewer4, JsonRpcBlockViewer as JsonRpcBlockViewer2, JsonRpcFinalizationViewer as JsonRpcFinalizationViewer2, JsonRpcMempoolRunner as JsonRpcMempoolRunner2, JsonRpcMempoolViewer as JsonRpcMempoolViewer2, JsonRpcXyoRunner as JsonRpcXyoRunner2, JsonRpcXyoViewer as JsonRpcXyoViewer2, ProviderFactoryLocator as ProviderFactoryLocator7, SimpleXyoConnectionRunner as SimpleXyoConnectionRunner3, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoRunner as SimpleXyoRunner3, SimpleXyoSigner as SimpleXyoSigner3 } from "@xyo-network/xl1-sdk";
 async function rewardRedemptionLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator6({
+  const locator = new ProviderFactoryLocator7({
     ...context,
     locator: parent
   });
@@ -1731,22 +1814,9 @@ async function rewardRedemptionLocatorFromConfig(context, parent) {
 }
 __name(rewardRedemptionLocatorFromConfig, "rewardRedemptionLocatorFromConfig");
 
-// src/node/config/locators/actors/validatorLocatorFromConfig.ts
-import { ProviderFactoryLocator as ProviderFactoryLocator7 } from "@xyo-network/xl1-sdk";
-function validatorLocatorFromConfig(context, parent) {
-  const locator = new ProviderFactoryLocator7({
-    ...context,
-    locator: parent
-  });
-  locator.registerMany([]);
-  locator.freeze();
-  return locator;
-}
-__name(validatorLocatorFromConfig, "validatorLocatorFromConfig");
-
 // src/node/config/locators/rootLocatorFromConfig.ts
 import { commonLocatorFromConfig, remoteLocatorFromConfig } from "@xyo-network/xl1-sdk";
-async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
+async function rootLocatorFromConfig(context, validateDepsOnRegister = false, onInsecureGenesisConfirm) {
   const { config } = context;
   let locator = await commonLocatorFromConfig(context, validateDepsOnRegister);
   const newLocator = await (config.remote.rpc ? remoteLocatorFromConfig(locator.context, validateDepsOnRegister) : localLocatorFromConfig({
@@ -1755,7 +1825,7 @@ async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
       ...locator.context.config,
       ...context.config
     }
-  }, validateDepsOnRegister));
+  }, validateDepsOnRegister, onInsecureGenesisConfirm));
   locator = newLocator;
   locator = await initEvmProvidersIfAvailable(locator);
   locator.freeze();
@@ -1764,15 +1834,17 @@ async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
 __name(rootLocatorFromConfig, "rootLocatorFromConfig");
 
 // src/node/config/locators/locatorsFromConfig.ts
-async function locatorsFromConfig(context, { actors, ...config }) {
+async function locatorsFromConfig(context, { actors, ...config }, onInsecureGenesisConfirm) {
+  const rootContext = {
+    ...context,
+    config: {
+      ...config,
+      name: "_root"
+    }
+  };
+  const rootLocator = await rootLocatorFromConfig(rootContext, false, onInsecureGenesisConfirm);
   const result = {
-    _root: await rootLocatorFromConfig({
-      ...context,
-      config: {
-        ...config,
-        name: "_root"
-      }
-    })
+    _root: rootLocator
   };
   for (const actorConfig of actors) {
     switch (actorConfig.name) {
@@ -1797,10 +1869,10 @@ async function locatorsFromConfig(context, { actors, ...config }) {
         }, result._root);
         break;
       }
-      case "validator": {
-        result[actorConfig.name] = await validatorLocatorFromConfig({
+      case "finalizer": {
+        result[actorConfig.name] = await finalizerLocatorFromConfig({
           ...context,
-          config: ValidatorConfigZod.parse(deepMerge2(config, actorConfig))
+          config: FinalizerConfigZod.parse(deepMerge2(config, actorConfig))
         }, result._root);
         break;
       }
@@ -1830,6 +1902,21 @@ import { ConfigZod } from "@xyo-network/xl1-sdk";
 import { cosmiconfig } from "cosmiconfig";
 var configName = "xyo";
 var configSection = "xl1";
+var ConfigFileNotFoundError = class extends Error {
+  static {
+    __name(this, "ConfigFileNotFoundError");
+  }
+  constructor(configPath) {
+    super(`Config file not found: ${configPath}`);
+    this.name = "ConfigFileNotFoundError";
+  }
+};
+var isMissingFileError = /* @__PURE__ */ __name((error) => {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}, "isMissingFileError");
+var isRecord = /* @__PURE__ */ __name((value) => {
+  return typeof value === "object" && value !== null;
+}, "isRecord");
 async function tryParseConfig(options) {
   const { configPath, searchPlaces } = options ?? {};
   const explorer = cosmiconfig(configName, {
@@ -1837,10 +1924,25 @@ async function tryParseConfig(options) {
     // loaders: { '.ts': TypeScriptLoader() },
     searchPlaces
   });
-  const result = isDefined4(configPath) ? (await explorer.load(configPath))?.config : (await explorer.search())?.config;
-  if (isDefined4(result) && !isNull(result)) {
+  let result;
+  if (isDefined4(configPath)) {
+    try {
+      result = (await explorer.load(configPath))?.config;
+    } catch (error) {
+      if (isMissingFileError(error)) {
+        throw new ConfigFileNotFoundError(configPath);
+      }
+      throw error;
+    }
+    if (!isDefined4(result) || isNull(result)) {
+      throw new ConfigFileNotFoundError(configPath);
+    }
+  } else {
+    result = (await explorer.search())?.config;
+  }
+  if (isRecord(result)) {
     const section = result[configSection];
-    if (isDefined4(section) && typeof section === "object") {
+    if (isRecord(section)) {
       const parsed = ConfigZod.loose().parse(section);
       return typeof section.mnemonic === "string" ? {
         ...parsed,
@@ -1857,6 +1959,7 @@ export * from "@xyo-network/chain-orchestration-evm";
 export * from "@xyo-network/chain-orchestration-express";
 export * from "@xyo-network/chain-orchestration-storage";
 export {
+  ActorMnemonicNotAllowedError,
   ApiConfigContext,
   ApiConfigZod,
   BUILT_IN_DEV_MNEMONIC,
@@ -1864,10 +1967,16 @@ export {
   BridgeConfigContext,
   BridgeConfigZod,
   BridgeSettingsZod,
+  ConfigFileNotFoundError,
+  DEFAULT_ACTOR_ACCOUNT_PATH,
   DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL,
   DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL,
   DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL,
   DefaultServiceProvider,
+  DerivationPathCollisionError,
+  FinalizerActor,
+  FinalizerConfigContext,
+  FinalizerConfigZod,
   GENESIS_REWARD_AMOUNT,
   GenericHost,
   INSECURE_GENESIS_REWARD_MNEMONIC,
@@ -1880,36 +1989,39 @@ export {
   ProducerConfigZod,
   PublicChildManifests,
   ROOT_WALLET_RUNTIME_ID,
+  RejectedTransactionsArchivistProviderMoniker,
   RewardRedemptionConfigContext,
   RewardRedemptionConfigZod,
   SHARED_ACCOUNT_REPORT_COUNT,
   ServiceLifetime,
-  ValidatorActor,
-  ValidatorConfigContext,
-  ValidatorConfigZod,
+  SimpleRejectedTransactionsArchivistProvider,
   asApiConfig,
   asApiConfigContext,
   asBridgeConfig,
   asBridgeConfigContext,
+  asFinalizerConfig,
+  asFinalizerConfigContext,
   asMempoolConfig,
   asMempoolConfigContext,
   asProducerConfig,
   asProducerConfigContext,
   asRewardRedemptionConfig,
   asRewardRedemptionConfigContext,
-  asValidatorConfig,
-  asValidatorConfigContext,
+  assertNoActorMnemonics,
   basicRemoteRunnerLocator,
   basicRemoteViewerLocator,
+  buildInsecureGenesisRewardAccounts,
   buildTelemetryConfig,
   clearResolvedWalletReport,
   contextFromConfigWithoutLocator,
   createProducerChainStakeIntentBlock,
+  detectDerivationPathCollisions,
+  expandAccountPath,
+  formatInsecureGenesisRewardWarning,
   formatWalletReport,
   getBuiltInDevMnemonic,
   getInsecureGenesisRewardMnemonic,
   getLocator,
-  getReservedActorIndex,
   getResolvedWalletReport,
   initActorAccount,
   initActorSeedPhrase,
@@ -1924,22 +2036,24 @@ export {
   initStatusReporter,
   initTransferSummaryMap,
   initializeResolvedWalletReport,
+  isAbsoluteAccountPath,
   isApiConfig,
   isApiConfigContext,
   isBridgeConfig,
   isBridgeConfigContext,
+  isFinalizerConfig,
+  isFinalizerConfigContext,
   isMempoolConfig,
   isMempoolConfigContext,
   isProducerConfig,
   isProducerConfigContext,
   isRewardRedemptionConfig,
   isRewardRedemptionConfigContext,
-  isValidatorConfig,
-  isValidatorConfigContext,
   loadNode,
   localLocatorFromConfig,
   locatorsFromConfig,
   mergeConfig,
+  resolveActorAccountPath,
   resolveActorWallet,
   resolveGenesisRewardAddress,
   resolveRootWallet,
@@ -1951,14 +2065,14 @@ export {
   toApiConfigContext,
   toBridgeConfig,
   toBridgeConfigContext,
+  toFinalizerConfig,
+  toFinalizerConfigContext,
   toMempoolConfig,
   toMempoolConfigContext,
   toProducerConfig,
   toProducerConfigContext,
   toRewardRedemptionConfig,
   toRewardRedemptionConfigContext,
-  toValidatorConfig,
-  toValidatorConfigContext,
   tryParseConfig
 };
 //# sourceMappingURL=index.mjs.map