@xyo-network/chain-orchestration 1.20.21 → 1.20.23

package/dist/browser/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/neutral/config/locators/basicRemoteRunnerLocator.ts
 import { basicRemoteRunnerLocator as sdkBasicRemoteRunnerLocator } from "@xyo-network/xl1-sdk";
 function basicRemoteRunnerLocator(name, remoteConfig, signerTransport, dataLakeEndpoint, validators) {
@@ -898,17 +954,18 @@ function basicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, validato
 __name(basicRemoteViewerLocator, "basicRemoteViewerLocator");
 
 // src/neutral/config/locators/rootLocatorFromConfig.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { commonLocatorFromConfig, remoteLocatorFromConfig } from "@xyo-network/xl1-sdk";
 async function rootLocatorFromConfig(context, validateDepsOnRegister = false) {
   const { config } = context;
   await commonLocatorFromConfig(context, validateDepsOnRegister);
-  const locator = assertEx3(await (config.remote.rpc ? remoteLocatorFromConfig(context, validateDepsOnRegister) : void 0), () => "Root locator could not be created from config. No supported configuration found.");
+  const locator = assertEx4(await (config.remote.rpc ? remoteLocatorFromConfig(context, validateDepsOnRegister) : void 0), () => "Root locator could not be created from config. No supported configuration found.");
   locator.freeze();
   return locator;
 }
 __name(rootLocatorFromConfig, "rootLocatorFromConfig");
 export {
+  ActorMnemonicNotAllowedError,
   ApiConfigContext,
   ApiConfigZod,
   BUILT_IN_DEV_MNEMONIC,
@@ -916,10 +973,15 @@ 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,
   GENESIS_REWARD_AMOUNT,
   GenericHost,
   INSECURE_GENESIS_REWARD_MNEMONIC,
@@ -929,34 +991,37 @@ export {
   ProducerConfigContext,
   ProducerConfigZod,
   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,
   createProducerChainStakeIntentBlock,
+  detectDerivationPathCollisions,
+  expandAccountPath,
+  formatInsecureGenesisRewardWarning,
   formatWalletReport,
   getBuiltInDevMnemonic,
   getInsecureGenesisRewardMnemonic,
-  getReservedActorIndex,
   getResolvedWalletReport,
   initActorAccount,
   initActorSeedPhrase,
@@ -965,19 +1030,21 @@ export {
   initBridgedModule,
   initStatusReporter,
   initializeResolvedWalletReport,
+  isAbsoluteAccountPath,
   isApiConfig,
   isApiConfigContext,
   isBridgeConfig,
   isBridgeConfigContext,
+  isFinalizerConfig,
+  isFinalizerConfigContext,
   isMempoolConfig,
   isMempoolConfigContext,
   isProducerConfig,
   isProducerConfigContext,
   isRewardRedemptionConfig,
   isRewardRedemptionConfigContext,
-  isValidatorConfig,
-  isValidatorConfigContext,
   mergeConfig,
+  resolveActorAccountPath,
   resolveActorWallet,
   resolveGenesisRewardAddress,
   resolveRootWallet,
@@ -988,13 +1055,13 @@ export {
   toApiConfigContext,
   toBridgeConfig,
   toBridgeConfigContext,
+  toFinalizerConfig,
+  toFinalizerConfigContext,
   toMempoolConfig,
   toMempoolConfigContext,
   toProducerConfig,
   toProducerConfigContext,
   toRewardRedemptionConfig,
-  toRewardRedemptionConfigContext,
-  toValidatorConfig,
-  toValidatorConfigContext
+  toRewardRedemptionConfigContext
 };
 //# sourceMappingURL=index.mjs.map