@xyo-network/chain-orchestration 1.23.2 → 2.0.1

package/dist/node/index.mjs

@@ -19,7 +19,7 @@ import {
   IdLogger
 } from "@xylabs/sdk-js";
 import { Semaphore } from "async-mutex";
-import z from "zod";
+import { z } from "zod/mini";
 var noopCounter = { add: () => {
 } };
 var noopUpDownCounter = { add: () => {
@@ -39,7 +39,7 @@ var ActorParamsV3Zod = z.object({
   account: AccountInstanceZod,
   locator: z.unknown(),
   name: CreatableNameZod,
-  statusReporter: StatusReporterInstanceZod.optional()
+  statusReporter: z.optional(StatusReporterInstanceZod)
 });
 function createDeferred() {
   let resolve;
@@ -255,11 +255,14 @@ import {
   zodToFactory
 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod, HostActorConfigZod } from "@xyo-network/xl1-sdk";
-import { globalRegistry, z as z2 } from "zod";
-var ApiConfigZod = HostActorConfigZod.extend(z2.object({
-  initRewardsCache: z2.union([z2.number(), z2.string(), z2.boolean()]).transform(
-    (v) => v !== "0" && v !== "false" && v !== false && v != 0
-  ).default(true).register(globalRegistry, {
+import { globalRegistry, z as z2 } from "zod/mini";
+var toBooleanDefaultTrue = (v) => v !== "0" && v !== "false" && v !== false && v !== 0;
+var toBooleanDefaultFalse = (v) => v === "1" || v === "true" || v === true || v === 1;
+var ApiConfigZod = z2.extend(HostActorConfigZod, {
+  initRewardsCache: z2._default(
+    z2.pipe(z2.union([z2.number(), z2.string(), z2.boolean()]), z2.transform(toBooleanDefaultTrue)),
+    true
+  ).register(globalRegistry, {
     description: "Whether to initialize the rewards cache on startup",
     title: "api.initRewardsCache",
     type: "boolean"
@@ -272,9 +275,10 @@ var ApiConfigZod = HostActorConfigZod.extend(z2.object({
    * balancer for horizontal scaling. Requires `remote.rpc` to point at the
    * upstream API/Finalizer/Mempool/Indexer surfaces.
    */
-  stateless: z2.union([z2.number(), z2.string(), z2.boolean()]).transform(
-    (v) => v === "1" || v === "true" || v === true || v == 1
-  ).default(false).register(globalRegistry, {
+  stateless: z2._default(
+    z2.pipe(z2.union([z2.number(), z2.string(), z2.boolean()]), z2.transform(toBooleanDefaultFalse)),
+    false
+  ).register(globalRegistry, {
     description: "Run the API actor as a stateless federation node (availableBackings: [network])",
     title: "api.stateless",
     type: "boolean"
@@ -293,18 +297,19 @@ var ApiConfigZod = HostActorConfigZod.extend(z2.object({
    * `false` per environment once external clients (explorers, wallets, dApps)
    * have moved their indexed-method calls to `/rpc/indexed`.
    */
-  legacyMixedRpc: z2.union([z2.number(), z2.string(), z2.boolean()]).transform(
-    (v) => v !== "0" && v !== "false" && v !== false && v != 0
-  ).default(true).register(globalRegistry, {
+  legacyMixedRpc: z2._default(
+    z2.pipe(z2.union([z2.number(), z2.string(), z2.boolean()]), z2.transform(toBooleanDefaultTrue)),
+    true
+  ).register(globalRegistry, {
     description: "Serve the full XyoConnection at POST /rpc (no surface filter). Set false to enforce node-surface-only at /rpc; indexed methods always available at /rpc/indexed regardless.",
     title: "api.legacyMixedRpc",
     type: "boolean"
   })
-}).shape);
+});
 var isApiConfig = zodIsFactory(ApiConfigZod);
 var asApiConfig = zodAsFactory(ApiConfigZod, "asApiConfig");
 var toApiConfig = zodToFactory(ApiConfigZod, "toApiConfig");
-var ApiConfigContext = BaseConfigContextZod.extend({ config: ApiConfigZod });
+var ApiConfigContext = z2.extend(BaseConfigContextZod, { config: ApiConfigZod });
 var isApiConfigContext = zodIsFactory(ApiConfigContext);
 var asApiConfigContext = zodAsFactory(ApiConfigContext, "asApiConfigContext");
 var toApiConfigContext = zodToFactory(ApiConfigContext, "toApiConfigContext");
@@ -325,7 +330,7 @@ import {
   HostActorConfigZod as HostActorConfigZod2,
   XL1
 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry2, z as z3 } from "zod";
+import { globalRegistry as globalRegistry2, z as z3 } from "zod/mini";
 var DEFAULT_FIXED_FEE = toHex(XL1(1000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_VARIABLE_FEE_BASIS_POINTS = 300;
 var DEFAULT_HARDHAT_BRIDGE_CONTRACT = toAddress("2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6");
@@ -335,103 +340,108 @@ var DEFAULT_HARDHAT_TOKEN_CONTRACT = toAddress("5FbDB2315678afecb367f032d93F642f
 var DEFAULT_MAX_BRIDGE_AMOUNT = toHex(XL1(1000000n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_MIN_BRIDGE_AMOUNT = toHex(XL1(1500n) * AttoXL1ConvertFactor.xl1);
 var DEFAULT_SCANNER_INTERVAL_MS = 3e4;
-var BasisPointsZod = z3.coerce.number().int().nonnegative().max(1e4);
-var BridgeConfigZod = HostActorConfigZod2.extend({
-  escrowAddress: AddressZod.optional().register(globalRegistry2, {
+var BasisPointsZod = z3.coerce.number().check(z3.multipleOf(1), z3.nonnegative(), z3.maximum(1e4));
+var BridgeConfigZod = z3.extend(HostActorConfigZod2, {
+  escrowAddress: z3.optional(AddressZod).register(globalRegistry2, {
     description: "Address to which bridge escrow will be sent",
     title: "bridge.escrowAddress",
     type: "string"
   }),
-  feesAddress: AddressZod.optional().register(globalRegistry2, {
+  feesAddress: z3.optional(AddressZod).register(globalRegistry2, {
     description: "Address to which bridge fees will be sent",
     title: "bridge.feesAddress",
     type: "string"
   }),
-  feeFixed: HexZod.default(DEFAULT_FIXED_FEE).register(globalRegistry2, {
+  feeFixed: z3._default(HexZod, DEFAULT_FIXED_FEE).register(globalRegistry2, {
     default: DEFAULT_FIXED_FEE,
     description: "Fixed fee (in AttoXL1) applied to bridge transfers",
     title: "bridge.feeFixed",
     type: "bigint"
   }),
-  feeRateBasisPoints: BasisPointsZod.default(DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
+  feeRateBasisPoints: z3._default(BasisPointsZod, DEFAULT_VARIABLE_FEE_BASIS_POINTS).register(globalRegistry2, {
     default: DEFAULT_VARIABLE_FEE_BASIS_POINTS,
     description: "Variable rate fee (in basis points where 1 bps = 0.01%) applied to bridge transfers",
     title: "bridge.feeRateBasisPoints",
     type: "number"
   }),
-  maxBridgeAmount: HexZod.default(DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
+  maxBridgeAmount: z3._default(HexZod, DEFAULT_MAX_BRIDGE_AMOUNT).register(globalRegistry2, {
     default: DEFAULT_MAX_BRIDGE_AMOUNT,
     description: "Maximum amount allowed for a bridge transfer",
     title: "bridge.maxBridgeAmount",
     type: "string"
   }),
-  minBridgeAmount: HexZod.default(DEFAULT_MIN_BRIDGE_AMOUNT).register(globalRegistry2, {
+  minBridgeAmount: z3._default(HexZod, 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(globalRegistry2, {
+  redisHost: z3._default(z3.string(), "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(globalRegistry2, {
+  redisPort: z3._default(z3.coerce.number().check(z3.multipleOf(1), z3.positive()), 6379).register(globalRegistry2, {
     default: 6379,
     description: "Port for the Bridge Redis instance",
     title: "bridge.redisPort",
     type: "number"
   }),
-  scannerIntervalMs: z3.coerce.number().int().positive().default(DEFAULT_SCANNER_INTERVAL_MS).register(globalRegistry2, {
+  scannerIntervalMs: z3._default(z3.coerce.number().check(z3.multipleOf(1), z3.positive()), DEFAULT_SCANNER_INTERVAL_MS).register(globalRegistry2, {
     default: DEFAULT_SCANNER_INTERVAL_MS,
     description: "How often (ms) the EVM->XL1 scanner polls the remote bridge contract for new BridgedToRemote ids confirmed at depth.",
     title: "bridge.scannerIntervalMs",
     type: "number"
   }),
-  remoteBridgeContractAddress: AddressZod.default(DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
+  remoteBridgeContractAddress: z3._default(AddressZod, DEFAULT_HARDHAT_BRIDGE_CONTRACT).register(globalRegistry2, {
     default: DEFAULT_HARDHAT_BRIDGE_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteBridgeContractAddress",
     type: "string"
   }),
-  remoteChainId: HexZod.default(DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
+  remoteBridgeContractDeployBlock: z3.optional(z3.coerce.number().check(z3.multipleOf(1), z3.nonnegative())).register(globalRegistry2, {
+    description: "EVM block at which the remote bridge contract was deployed. When unset, the bridge actor probes the chain via eth_getCode at actor startup. Setting this avoids the probe and is cheaper for chains with high heads; it must be at or before the actual deploy block.",
+    title: "bridge.remoteBridgeContractDeployBlock",
+    type: "number"
+  }),
+  remoteChainId: z3._default(HexZod, DEFAULT_HARDHAT_CHAIN_ID).register(globalRegistry2, {
     default: DEFAULT_HARDHAT_CHAIN_ID,
     description: "Remote chain ID",
     title: "bridge.remoteChainId",
     type: "string"
   }),
-  remoteConfirmationDepth: z3.union([
-    z3.coerce.number().int().nonnegative(),
+  remoteConfirmationDepth: z3.optional(z3.union([
+    z3.coerce.number().check(z3.multipleOf(1), z3.nonnegative()),
     z3.literal("finalized")
-  ]).optional().register(globalRegistry2, {
+  ])).register(globalRegistry2, {
     description: "Block depth or BlockTag at which the remote (EVM) chain is read as canonical. Numeric: number of confirmations behind head. 'finalized': Casper FFG finalized block. Resolved per-chain by getRemoteConfirmationDepth when unset.",
     title: "bridge.remoteConfirmationDepth",
     type: "string"
   }),
-  remoteTokenAddress: HexZod.default(DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
+  remoteTokenAddress: z3._default(HexZod, DEFAULT_HARDHAT_TOKEN_CONTRACT).register(globalRegistry2, {
     default: DEFAULT_HARDHAT_TOKEN_CONTRACT,
     description: "Hex representation of remote token address used for bridging",
     title: "bridge.remoteTokenAddress",
     type: "string"
   }),
-  remoteChainWalletPrivateKey: HexZod.default(DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
+  remoteChainWalletPrivateKey: z3._default(HexZod, DEFAULT_HARDHAT_REMOTE_CHAIN_WALLET_PRIVATE_KEY).register(globalRegistry2, {
     description: "Private key for the wallet to use for the remote chain wallet",
     title: "bridge.remoteChainWalletPrivateKey",
     type: "string"
   }),
-  xl1ChainId: HexZod.optional().register(globalRegistry2, {
+  xl1ChainId: z3.optional(HexZod).register(globalRegistry2, {
     description: "XL1 chain id used for bridging",
     title: "bridge.xl1ChainId",
     type: "string"
   }),
-  xl1TokenAddress: HexZod.optional().register(globalRegistry2, {
+  xl1TokenAddress: z3.optional(HexZod).register(globalRegistry2, {
     description: "XL1 token address used for bridging",
     title: "bridge.xl1TokenAddress",
     type: "string"
   })
 });
-var BridgeSettingsZod = BridgeConfigZod.pick({
+var BridgeSettingsZod = z3.required(z3.pick(BridgeConfigZod, {
   feeFixed: true,
   feeRateBasisPoints: true,
   feesAddress: true,
@@ -442,11 +452,11 @@ var BridgeSettingsZod = BridgeConfigZod.pick({
   remoteTokenAddress: true,
   xl1TokenAddress: true,
   xl1ChainId: true
-}).required();
+}));
 var isBridgeConfig = zodIsFactory2(BridgeConfigZod);
 var asBridgeConfig = zodAsFactory2(BridgeConfigZod, "asBridgeConfig");
 var toBridgeConfig = zodToFactory2(BridgeConfigZod, "toBridgeConfig");
-var BridgeConfigContext = BaseConfigContextZod2.extend({ config: BridgeConfigZod });
+var BridgeConfigContext = z3.extend(BaseConfigContextZod2, { config: BridgeConfigZod });
 var isBridgeConfigContext = zodIsFactory2(BridgeConfigContext);
 var asBridgeConfigContext = zodAsFactory2(BridgeConfigContext, "asBridgeConfigContext");
 var toBridgeConfigContext = zodToFactory2(BridgeConfigContext, "toBridgeConfigContext");
@@ -463,19 +473,19 @@ import {
   DEFAULT_MIN_CANDIDATES,
   HostActorConfigZod as HostActorConfigZod3
 } from "@xyo-network/xl1-sdk";
-import { z as z4 } from "zod";
-var FinalizerConfigZod = HostActorConfigZod3.extend({
-  allowedProducers: z4.array(AddressZod2).optional(),
+import { z as z4 } from "zod/mini";
+var FinalizerConfigZod = z4.extend(HostActorConfigZod3, {
+  allowedProducers: z4.optional(z4.array(AddressZod2)),
   // Period (ms) between finalizer ticks. Default matches the historical
   // hardcoded value in FinalizerActor; tests can lower it to drive faster
   // block finalization.
-  finalizationCheckInterval: z4.coerce.number().default(500),
-  minCandidates: z4.number().int().min(0).default(DEFAULT_MIN_CANDIDATES)
+  finalizationCheckInterval: z4._default(z4.coerce.number(), 500),
+  minCandidates: z4._default(z4.number().check(z4.multipleOf(1), z4.nonnegative()), DEFAULT_MIN_CANDIDATES)
 });
 var isFinalizerConfig = zodIsFactory3(FinalizerConfigZod);
 var asFinalizerConfig = zodAsFactory3(FinalizerConfigZod, "asFinalizerConfig");
 var toFinalizerConfig = zodToFactory3(FinalizerConfigZod, "toFinalizerConfig");
-var FinalizerConfigContext = BaseConfigContextZod3.extend({ config: FinalizerConfigZod });
+var FinalizerConfigContext = z4.extend(BaseConfigContextZod3, { config: FinalizerConfigZod });
 var isFinalizerConfigContext = zodIsFactory3(FinalizerConfigContext);
 var asFinalizerConfigContext = zodAsFactory3(FinalizerConfigContext, "asFinalizerConfigContext");
 var toFinalizerConfigContext = zodToFactory3(FinalizerConfigContext, "toFinalizerConfigContext");
@@ -487,45 +497,53 @@ import {
   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 z5 } from "zod";
+import { globalRegistry as globalRegistry3, z as z5 } from "zod/mini";
 var DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL = 1e3;
 var DEFAULT_MEMPOOL_DEMOTION_THRESHOLD = 3;
 var DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS = 0;
-var MempoolConfigZod = HostActorConfigZod4.extend({
-  enabled: z5.union([z5.string(), z5.boolean()]).default("false").transform((val, ctx) => {
-    if (typeof val === "boolean") return val;
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
+var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
+var FlexibleBooleanZod = z5.pipe(
+  z5.union([z5.string(), z5.boolean()]).check(z5.refine((val) => {
+    if (typeof val === "boolean") return true;
     const normalized = val.toLowerCase().trim();
-    if (["true", "1", "yes", "on"].includes(normalized)) return true;
-    if (["false", "0", "no", "off"].includes(normalized)) return false;
-    ctx.addIssue({
-      code: "invalid_type",
-      expected: "boolean",
-      message: `Invalid boolean value: "${val}". Use true/false, 1/0, yes/no.`
-    });
-    return z5.NEVER;
-  }).register(globalRegistry3, {
-    default: "false",
+    return TRUE_VALUES.has(normalized) || FALSE_VALUES.has(normalized);
+  }, { error: "Invalid boolean value. Use true/false, 1/0, yes/no." })),
+  z5.transform((val) => {
+    if (typeof val === "boolean") return val;
+    return TRUE_VALUES.has(val.toLowerCase().trim());
+  })
+);
+var MempoolConfigZod = z5.extend(HostActorConfigZod4, {
+  enabled: z5._default(FlexibleBooleanZod, false).register(globalRegistry3, {
+    default: false,
     description: "Enable the Mempool",
     title: "mempool.enabled",
     type: "boolean"
   }),
-  blockPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
+  blockPruneInterval: z5._default(z5.coerce.number(), DEFAULT_MEMPOOL_BLOCK_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending block prune attempts",
     title: "mempool.blockPruneInterval",
     type: "number"
   }),
-  demotionThreshold: z5.coerce.number().int().positive().default(DEFAULT_MEMPOOL_DEMOTION_THRESHOLD).register(globalRegistry3, {
+  demotionThreshold: z5._default(
+    z5.coerce.number().check(z5.multipleOf(1), z5.positive()),
+    DEFAULT_MEMPOOL_DEMOTION_THRESHOLD
+  ).register(globalRegistry3, {
     description: "Number of times a transaction may be handed out to producers without being included in a block before it is considered demoted",
     title: "mempool.demotionThreshold",
     type: "number"
   }),
-  maxPendingTransactions: z5.coerce.number().int().nonnegative().default(DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS).register(globalRegistry3, {
+  maxPendingTransactions: z5._default(
+    z5.coerce.number().check(z5.multipleOf(1), z5.nonnegative()),
+    DEFAULT_MEMPOOL_MAX_PENDING_TRANSACTIONS
+  ).register(globalRegistry3, {
     description: "Maximum number of pending transactions in the pool. When exceeded, demoted transactions are evicted first, then oldest by sequence. 0 disables the cap.",
     title: "mempool.maxPendingTransactions",
     type: "number"
   }),
-  transactionPruneInterval: z5.coerce.number().default(DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
+  transactionPruneInterval: z5._default(z5.coerce.number(), DEFAULT_MEMPOOL_TRANSACTION_PRUNE_INTERVAL).register(globalRegistry3, {
     description: "The interval time (in milliseconds) between pending transaction prune attempts",
     title: "mempool.transactionPruneInterval",
     type: "number"
@@ -534,7 +552,7 @@ var MempoolConfigZod = HostActorConfigZod4.extend({
 var isMempoolConfig = zodIsFactory4(MempoolConfigZod);
 var asMempoolConfig = zodAsFactory4(MempoolConfigZod, "asMempoolConfig");
 var toMempoolConfig = zodToFactory4(MempoolConfigZod, "toMempoolConfig");
-var MempoolConfigContext = BaseConfigContextZod4.extend({ config: MempoolConfigZod });
+var MempoolConfigContext = z5.extend(BaseConfigContextZod4, { config: MempoolConfigZod });
 var isMempoolConfigContext = zodIsFactory4(MempoolConfigContext);
 var asMempoolConfigContext = zodAsFactory4(MempoolConfigContext, "asMempoolConfigContext");
 var toMempoolConfigContext = zodToFactory4(MempoolConfigContext, "toMempoolConfigContext");
@@ -547,46 +565,46 @@ import {
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
 import { ActorConfigZod, BaseConfigContextZod as BaseConfigContextZod5 } from "@xyo-network/xl1-sdk";
-import { globalRegistry as globalRegistry4, z as z6 } from "zod";
+import { globalRegistry as globalRegistry4, z as z6 } from "zod/mini";
 var DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL = 1e4;
-var ProducerConfigZod = ActorConfigZod.extend(z6.object({
-  allowlist: z6.array(AddressZod3).optional().register(globalRegistry4, {
+var ProducerConfigZod = z6.extend(ActorConfigZod, {
+  allowlist: z6.optional(z6.array(AddressZod3)).register(globalRegistry4, {
     description: "List of allowed producer addresses, if undefined anyone can participate",
     title: "allowlist",
     type: "array"
   }),
-  blockProductionCheckInterval: z6.coerce.number().default(DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
+  blockProductionCheckInterval: z6._default(z6.coerce.number(), DEFAULT_BLOCK_PRODUCTION_CHECK_INTERVAL).register(globalRegistry4, {
     description: "The interval time (in milliseconds) between block production attempts",
     title: "producer.blockProductionCheckInterval",
     type: "number"
   }),
-  disableIntentRedeclaration: z6.boolean().optional().register(globalRegistry4, {
+  disableIntentRedeclaration: z6.optional(z6.boolean()).register(globalRegistry4, {
     description: "Should the producer skip redeclaring their intent to continue producing blocks",
     title: "producer.disableIntentRedeclaration",
     type: "boolean"
   }),
-  heartbeatInterval: z6.coerce.number().default(36e5).register(globalRegistry4, {
+  heartbeatInterval: z6._default(z6.coerce.number(), 36e5).register(globalRegistry4, {
     description: "The number of milliseconds between heartbeats if no blocks are produced",
     title: "producer.heartbeatInterval",
     type: "number"
   }),
   // TODO: BigInt schema
-  minStake: z6.coerce.number().default(1).register(globalRegistry4, {
+  minStake: z6._default(z6.coerce.number(), 1).register(globalRegistry4, {
     description: "Minimum stake required to be a Producer",
     title: "producer.minStake",
     type: "number"
   }),
   // TODO: Address schema
-  rewardAddress: z6.string().optional().register(globalRegistry4, {
+  rewardAddress: z6.optional(z6.string()).register(globalRegistry4, {
     description: "Address to receive block rewards",
     title: "producer.rewardAddress",
     type: "string"
   })
-}).shape);
+});
 var isProducerConfig = zodIsFactory5(ProducerConfigZod);
 var asProducerConfig = zodAsFactory5(ProducerConfigZod, "asProducerConfig");
 var toProducerConfig = zodToFactory5(ProducerConfigZod, "toProducerConfig");
-var ProducerConfigContext = BaseConfigContextZod5.extend({ config: ProducerConfigZod });
+var ProducerConfigContext = z6.extend(BaseConfigContextZod5, { config: ProducerConfigZod });
 var isProducerConfigContext = zodIsFactory5(ProducerConfigContext);
 var asProducerConfigContext = zodAsFactory5(ProducerConfigContext, "asProducerConfigContext");
 var toProducerConfigContext = zodToFactory5(ProducerConfigContext, "toProducerConfigContext");
@@ -598,11 +616,12 @@ import {
   zodToFactory as zodToFactory6
 } from "@xylabs/sdk-js";
 import { BaseConfigContextZod as BaseConfigContextZod6, HostActorConfigZod as HostActorConfigZod5 } from "@xyo-network/xl1-sdk";
-var RewardRedemptionConfigZod = HostActorConfigZod5.extend({});
+import { z as z7 } from "zod/mini";
+var RewardRedemptionConfigZod = z7.extend(HostActorConfigZod5, {});
 var isRewardRedemptionConfig = zodIsFactory6(RewardRedemptionConfigZod);
 var asRewardRedemptionConfig = zodAsFactory6(RewardRedemptionConfigZod, "asRewardRedemptionConfig");
 var toRewardRedemptionConfig = zodToFactory6(RewardRedemptionConfigZod, "toRewardRedemptionConfig");
-var RewardRedemptionConfigContext = BaseConfigContextZod6.extend({ config: RewardRedemptionConfigZod });
+var RewardRedemptionConfigContext = z7.extend(BaseConfigContextZod6, { config: RewardRedemptionConfigZod });
 var isRewardRedemptionConfigContext = zodIsFactory6(RewardRedemptionConfigContext);
 var asRewardRedemptionConfigContext = zodAsFactory6(RewardRedemptionConfigContext, "asRewardRedemptionConfigContext");
 var toRewardRedemptionConfigContext = zodToFactory6(RewardRedemptionConfigContext, "toRewardRedemptionConfigContext");
@@ -2906,6 +2925,7 @@ async function locatorsFromConfig(context, { actors, ...config }, onInsecureGene
 import { isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
 import { ConfigZod } from "@xyo-network/xl1-sdk";
 import { cosmiconfig } from "cosmiconfig";
+import { z as z8 } from "zod/mini";
 var configName = "xyo";
 var configSection = "xl1";
 var ConfigFileNotFoundError = class extends Error {
@@ -2949,7 +2969,7 @@ async function tryParseConfig(options) {
   if (isRecord(result)) {
     const section = result[configSection];
     if (isRecord(section)) {
-      const parsed = ConfigZod.loose().parse(section);
+      const parsed = z8.looseObject(ConfigZod.shape).parse(section);
       return typeof section.mnemonic === "string" ? { ...parsed, mnemonic: section.mnemonic } : parsed;
     }
   }