@xyo-network/xl1-protocol-sdk 1.26.35 → 1.26.36

package/dist/neutral/index.mjs

@@ -699,36 +699,15 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry12, z as z18 } from "zod";
-
-// src/validation/lib/isLocalhost.ts
-var isLocalhost = (hostname) => {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
-};
-
-// src/validation/lib/getUrl.ts
-var getUrl = (host, port) => {
-  const scheme = isLocalhost(host) ? "http" : "https";
-  return `${scheme}://${host}:${port}`;
-};
-
-// src/validation/schema/Address.ts
-var TODO = true;
-
-// src/validation/schema/Mnemonic.ts
-import { z as z2 } from "zod";
-var MnemonicStringZod = z2.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
-  (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
-  { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
-).describe("BIP-39 mnemonic string");
+import { globalRegistry as globalRegistry12, z as z17 } from "zod";
 
 // src/config/Base.ts
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 
 // src/config/Chain.ts
 import { AddressZod, HexZod } from "@xylabs/sdk-js";
-import { globalRegistry, z as z3 } from "zod";
-var ChainConfigZod = z3.object({
+import { globalRegistry, z as z2 } from "zod";
+var ChainConfigZod = z2.object({
   id: HexZod.optional().register(globalRegistry, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
     title: "chain.id",
@@ -742,15 +721,15 @@ var ChainConfigZod = z3.object({
 });
 
 // src/config/DataLake/DataLake.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry3, z as z5 } from "zod";
+import { globalRegistry as globalRegistry3, z as z4 } from "zod";
 
 // src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry2, z as z4 } from "zod";
-var DataLakeDriverConfigBaseZod = z4.object({
-  driver: z4.string().register(globalRegistry2, {
+import { globalRegistry as globalRegistry2, z as z3 } from "zod";
+var DataLakeDriverConfigBaseZod = z3.object({
+  driver: z3.string().register(globalRegistry2, {
     description: "Driver for the data lake",
     type: "string"
   })
@@ -758,55 +737,55 @@ var DataLakeDriverConfigBaseZod = z4.object({
 
 // src/config/DataLake/RestDataLakeConfig.ts
 var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z5.literal("rest").register(globalRegistry3, {
+  driver: z4.literal("rest").register(globalRegistry3, {
     description: "Driver for the REST data lake",
     type: "string"
   }),
-  url: z5.string().register(globalRegistry3, {
+  url: z4.string().register(globalRegistry3, {
     description: "URL for the REST data lake",
     type: "string"
   })
 }).describe("Configuration for the REST data lake driver");
 
 // src/config/DataLake/RouterDataLakeConfig.ts
-import { globalRegistry as globalRegistry4, z as z6 } from "zod";
-var RouterDataLakeConfigZod = z6.object({
-  driver: z6.literal("router").register(globalRegistry4, {
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+var RouterDataLakeConfigZod = z5.object({
+  driver: z5.literal("router").register(globalRegistry4, {
     description: "Driver for the router data lake",
     type: "string"
   }),
-  children: z6.array(z6.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
+  children: z5.array(z5.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
     description: "Child data lake drivers",
     type: "array"
   })
 }).describe("Configuration for the router data lake driver");
 
 // src/config/DataLake/DataLake.ts
-var DataLakeConfigZod = z7.lazy(() => z7.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
+var DataLakeConfigZod = z6.lazy(() => z6.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5, z as z8 } from "zod";
-var EvmInfuraConfigZod = z8.object({
-  projectId: z8.string().optional().register(globalRegistry5, {
+import { globalRegistry as globalRegistry5, z as z7 } from "zod";
+var EvmInfuraConfigZod = z7.object({
+  projectId: z7.string().optional().register(globalRegistry5, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z8.string().optional().register(globalRegistry5, {
+  projectSecret: z7.string().optional().register(globalRegistry5, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z8.object({
-  url: z8.url().optional().register(globalRegistry5, {
+var EvmJsonRpcConfigZod = z7.object({
+  url: z7.url().optional().register(globalRegistry5, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z8.object({
-  chainId: z8.string().optional().register(globalRegistry5, {
+var EvmConfigZod = z7.object({
+  chainId: z7.string().optional().register(globalRegistry5, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -817,17 +796,17 @@ var EvmConfigZod = z8.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6, z as z9 } from "zod";
+import { globalRegistry as globalRegistry6, z as z8 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z9.object({
-  logLevel: z9.enum(LogLevelNames).default("info").register(globalRegistry6, {
+var LogConfigZod = z8.object({
+  logLevel: z8.enum(LogLevelNames).default("info").register(globalRegistry6, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z9.boolean().default(false).register(globalRegistry6, {
+  silent: z8.boolean().default(false).register(globalRegistry6, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -836,7 +815,7 @@ var LogConfigZod = z9.object({
 });
 
 // src/config/Providers.ts
-import z11 from "zod";
+import z10 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -844,83 +823,83 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z10 } from "zod";
-var ProviderConfigZod = z10.object({
-  moniker: z10.string(),
-  labels: z10.array(z10.string()).optional()
+import { z as z9 } from "zod";
+var ProviderConfigZod = z9.object({
+  moniker: z9.string(),
+  labels: z9.array(z9.string()).optional()
 }).describe("Configuration for a Provider");
 var isProviderConfig = zodIsFactory(ProviderConfigZod);
 var asProviderConfig = zodAsFactory(ProviderConfigZod, "asProviderConfig");
 var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
 
 // src/config/Providers.ts
-var ProvidersConfigZod = z11.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
+var ProvidersConfigZod = z10.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/Remote.ts
-import { globalRegistry as globalRegistry7, z as z12 } from "zod";
-var RpcRemoteConfigBaseZod = z12.object({
-  protocol: z12.string("http").register(globalRegistry7, {
+import { globalRegistry as globalRegistry7, z as z11 } from "zod";
+var RpcRemoteConfigBaseZod = z11.object({
+  protocol: z11.string("http").register(globalRegistry7, {
     description: "Protocol for the RPC connection",
     type: "string"
   })
 }).describe("Base configuration for the remote RPC");
 var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z12.string("http").register(globalRegistry7, {
+  protocol: z11.string("http").register(globalRegistry7, {
     description: "Protocol for the RPC connection",
     type: "string"
   }).default("http"),
-  url: z12.string().register(globalRegistry7, {
+  url: z11.string().register(globalRegistry7, {
     description: "URL for the Chain RPC API",
     type: "string"
   })
 }).describe("Configuration for the remote RPC using Http");
 var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z12.string().register(globalRegistry7, {
+  protocol: z11.string().register(globalRegistry7, {
     description: "Protocol for the RPC connection",
     type: "string"
   }).default("postMessage"),
-  networkId: z12.string().register(globalRegistry7, {
+  networkId: z11.string().register(globalRegistry7, {
     description: "Network ID to use for the postMessage RPC connection",
     type: "string"
   }),
-  sessionId: z12.string().register(globalRegistry7, {
+  sessionId: z11.string().register(globalRegistry7, {
     description: "Session ID to use for the postMessage RPC connection",
     type: "string"
   })
 }).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z12.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z12.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+var RpcRemoteConfigZod = z11.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z11.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
 
 // src/config/storage/driver/Mongo.ts
 import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry8, z as z13 } from "zod";
+import { globalRegistry as globalRegistry8, z as z12 } from "zod";
 var hasMongoConfig = (config) => {
   if (isUndefined2(config)) return false;
   return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain) && isDefined4(config.password) && isDefined4(config.username);
 };
-var MongoConfigZod = z13.object({
+var MongoConfigZod = z12.object({
   // TODO: Create from other arguments
-  connectionString: z13.string().nonempty().optional().register(globalRegistry8, {
+  connectionString: z12.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z13.string().nonempty().optional().register(globalRegistry8, {
+  database: z12.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z13.string().nonempty().optional().register(globalRegistry8, {
+  domain: z12.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z13.string().nonempty().optional().register(globalRegistry8, {
+  password: z12.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z13.string().nonempty().optional().register(globalRegistry8, {
+  username: z12.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
@@ -928,10 +907,10 @@ var MongoConfigZod = z13.object({
 });
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry9, z as z14 } from "zod";
-var StorageConfigZod = z14.object({
+import { globalRegistry as globalRegistry9, z as z13 } from "zod";
+var StorageConfigZod = z13.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z14.string().optional().register(globalRegistry9, {
+  root: z13.string().optional().register(globalRegistry9, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -939,7 +918,7 @@ var StorageConfigZod = z14.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry10, z as z15 } from "zod";
+import { globalRegistry as globalRegistry10, z as z14 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -947,29 +926,29 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z15.object({
-  path: z15.string().default("/metrics").register(globalRegistry10, {
+var MetricsScrapeConfigZod = z14.object({
+  path: z14.string().default("/metrics").register(globalRegistry10, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z15.coerce.number().int().positive().optional().register(globalRegistry10, {
+  port: z14.coerce.number().int().positive().optional().register(globalRegistry10, {
     description: "Port for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z15.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z15.object({
+var MetricsConfigZod = z14.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z14.object({
   // OpenTelemetry options
-  otlpEndpoint: z15.url().optional().register(globalRegistry10, {
+  otlpEndpoint: z14.url().optional().register(globalRegistry10, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z15.object({
+var TelemetryConfigZod = z14.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -978,7 +957,7 @@ var TelemetryConfigZod = z15.object({
 
 // src/config/Validation.ts
 import { AddressZod as AddressZod2, asAddress } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry11, z as z16 } from "zod";
+import { globalRegistry as globalRegistry11, z as z15 } from "zod";
 
 // src/primitives/block/range/blockRangeSteps.ts
 import { asXL1BlockNumber as asXL1BlockNumber2, StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
@@ -1911,34 +1890,34 @@ function findUncles(context, finalizedWindowedChain, blocks) {
 }
 
 // src/config/Validation.ts
-var ValidationConfigZod = z16.object({
-  allowedRewardRedeemers: z16.preprocess((val) => {
+var ValidationConfigZod = z15.object({
+  allowedRewardRedeemers: z15.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z16.array(AddressZod2).optional().register(globalRegistry11, {
+  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   })),
-  allowedRewardEscrowAccountSigners: z16.preprocess((val) => {
+  allowedRewardEscrowAccountSigners: z15.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z16.array(AddressZod2).optional().register(globalRegistry11, {
+  }, z15.array(AddressZod2).optional().register(globalRegistry11, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   })),
-  minCandidates: z16.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry11, {
+  minCandidates: z15.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry11, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z16.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry11, {
+  backoffMs: z15.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry11, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -1947,7 +1926,7 @@ var ValidationConfigZod = z16.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z17.object({
+var BaseConfigZod = z16.object({
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
   dataLake: DataLakeConfigZod.optional().describe("Configuration for data lakes"),
   evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe("Configuration for EVM-backed services"),
@@ -1960,14 +1939,18 @@ var BaseConfigZod = z17.object({
 });
 
 // src/config/Actor.ts
+var AccountPathZod = z17.string().regex(
+  /^(m(\/\d+'?)+|\d+'?(\/\d+'?)*)$/,
+  `Invalid BIP-32 derivation path. Use either an absolute path like "m/44'/60'/0'/0/0" or a relative path like "0", "0/1", or "44'/60'/0'/0/0".`
+);
 var ActorConfigZod = BaseConfigZod.extend({
-  name: z18.string(),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry12, {
-    description: "Mnemonic for the Actor wallet",
-    title: "mnemonic",
+  name: z17.string(),
+  accountPath: AccountPathZod.optional().register(globalRegistry12, {
+    description: 'BIP-32 derivation path for the actor wallet. Absolute when it starts with "m/"; otherwise relative to the root wallet base path. Each actor must derive to a distinct path.',
+    title: "accountPath",
     type: "string"
   }),
-  healthCheckPort: z18.coerce.number().optional().register(globalRegistry12, {
+  healthCheckPort: z17.coerce.number().optional().register(globalRegistry12, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
@@ -1978,8 +1961,8 @@ var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import z19 from "zod";
-var ActorsConfigZod = z19.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
+import z18 from "zod";
+var ActorsConfigZod = z18.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
 
 // src/config/Config.ts
 var ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
@@ -1998,15 +1981,15 @@ import {
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry13, z as z20 } from "zod";
+import { globalRegistry as globalRegistry13, z as z19 } from "zod";
 var HostActorConfigZod = ActorConfigZod.extend({
-  host: z20.string().default("localhost").register(globalRegistry13, {
+  host: z19.string().default("localhost").register(globalRegistry13, {
     default: "localhost",
     description: "Host for the Actor",
     title: "host",
     type: "string"
   }),
-  port: z20.coerce.number().default(8080).register(globalRegistry13, {
+  port: z19.coerce.number().default(8080).register(globalRegistry13, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -2018,30 +2001,30 @@ var asHostActorConfig = zodAsFactory3(HostActorConfigZod, "asHostActorConfig");
 var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
 
 // src/config/UsageMeta.ts
-import { z as z21 } from "zod";
-var DescriptionSchema = z21.string();
-var TitleSchema = z21.string();
-var JSONSchemaMetaSchema = z21.object({
-  id: z21.string().optional(),
+import { z as z20 } from "zod";
+var DescriptionSchema = z20.string();
+var TitleSchema = z20.string();
+var JSONSchemaMetaSchema = z20.object({
+  id: z20.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z21.boolean().optional()
-}).catchall(z21.unknown());
+  deprecated: z20.boolean().optional()
+}).catchall(z20.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z21.array(z21.union([z21.string(), z21.number(), z21.literal(true), z21.undefined()])).readonly();
+var ChoicesSchema = z20.array(z20.union([z20.string(), z20.number(), z20.literal(true), z20.undefined()])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z21.unknown().optional(),
+  default: z20.unknown().optional(),
   description: DescriptionSchema,
-  group: z21.string().optional(),
-  hidden: z21.boolean().optional(),
+  group: z20.string().optional(),
+  hidden: z20.boolean().optional(),
   title: TitleSchema,
-  type: z21.union([
-    z21.literal("array"),
-    z21.literal("count"),
-    z21.literal("boolean"),
-    z21.literal("number"),
-    z21.literal("string")
+  type: z20.union([
+    z20.literal("array"),
+    z20.literal("count"),
+    z20.literal("boolean"),
+    z20.literal("number"),
+    z20.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -2062,15 +2045,15 @@ import {
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z22 } from "zod";
-var RuntimeStatusMonitorZod = z22.custom((val) => val && typeof val === "object");
-var ProviderFactoryLocatorZod = z22.lazy(() => z22.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
+import { z as z21 } from "zod";
+var RuntimeStatusMonitorZod = z21.custom((val) => val && typeof val === "object");
+var ProviderFactoryLocatorZod = z21.lazy(() => z21.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
 var BaseConfigContextZod = CachingContextZod.extend({
   config: BaseConfigZod.loose(),
   locator: ProviderFactoryLocatorZod.optional()
 });
-var CreatableProviderContextZod = z22.lazy(() => BaseConfigContextZod.extend({
-  _id: z22.string().optional(),
+var CreatableProviderContextZod = z21.lazy(() => BaseConfigContextZod.extend({
+  _id: z21.string().optional(),
   locator: ProviderFactoryLocatorZod,
   statusReporter: RuntimeStatusMonitorZod.optional()
 }));
@@ -2942,26 +2925,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 
 // src/eip-712/Types.ts
-import { z as z23 } from "zod";
-var TypedDataDomainZod = z23.object({
-  name: z23.string().nullable().optional(),
-  version: z23.string().nullable().optional(),
-  chainId: z23.union([z23.string(), z23.number(), z23.bigint()]).nullable().optional(),
-  verifyingContract: z23.string().nullable().optional(),
-  salt: z23.union([z23.string(), z23.instanceof(Uint8Array)]).nullable().optional()
+import { z as z22 } from "zod";
+var TypedDataDomainZod = z22.object({
+  name: z22.string().nullable().optional(),
+  version: z22.string().nullable().optional(),
+  chainId: z22.union([z22.string(), z22.number(), z22.bigint()]).nullable().optional(),
+  verifyingContract: z22.string().nullable().optional(),
+  salt: z22.union([z22.string(), z22.instanceof(Uint8Array)]).nullable().optional()
 });
-var TypedDataFieldZod = z23.object({
-  name: z23.string(),
-  type: z23.string()
+var TypedDataFieldZod = z22.object({
+  name: z22.string(),
+  type: z22.string()
 });
-var TypedDataTypesZod = z23.record(z23.string(), z23.array(TypedDataFieldZod));
-var TypedDataValueZod = z23.record(z23.string(), z23.any());
+var TypedDataTypesZod = z22.record(z22.string(), z22.array(TypedDataFieldZod));
+var TypedDataValueZod = z22.record(z22.string(), z22.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z24.object({
+var EIP712DataPayloadFieldsZod = z23.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -2979,11 +2962,11 @@ import {
   asSchema as asSchema3,
   isPayloadOfZodType as isPayloadOfZodType2
 } from "@xyo-network/sdk-js";
-import { z as z25 } from "zod";
-var EIP712SignaturePayloadFieldsZod = z25.object({
-  address: z25.string(),
+import { z as z24 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z24.object({
+  address: z24.string(),
   hash: HashZod,
-  signature: z25.string()
+  signature: z24.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -3722,12 +3705,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z26.ZodError;
+  return error instanceof z25.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z26.prettifyError(error);
+  return z25.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -4181,7 +4164,7 @@ import { isAnyPayload as isAnyPayload6, PayloadZodLoose } from "@xyo-network/sdk
 import {
   DataLakeRunnerMoniker
 } from "@xyo-network/xl1-protocol-lib";
-import z27 from "zod";
+import z26 from "zod";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { axiosJsonConfig } from "@xylabs/sdk-js";
@@ -4248,7 +4231,7 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.axios.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z27.array(PayloadZodLoose).parse(result.data);
+      return z26.array(PayloadZodLoose).parse(result.data);
     } else {
       return [];
     }
@@ -6199,6 +6182,27 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   return assertEx47(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 
+// src/validation/lib/isLocalhost.ts
+var isLocalhost = (hostname) => {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost");
+};
+
+// src/validation/lib/getUrl.ts
+var getUrl = (host, port) => {
+  const scheme = isLocalhost(host) ? "http" : "https";
+  return `${scheme}://${host}:${port}`;
+};
+
+// src/validation/schema/Address.ts
+var TODO = true;
+
+// src/validation/schema/Mnemonic.ts
+import { z as z27 } from "zod";
+var MnemonicStringZod = z27.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+  (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
+  { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
+).describe("BIP-39 mnemonic string");
+
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
 import { HDWallet } from "@xyo-network/sdk-js";
 
@@ -6219,6 +6223,7 @@ export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,
   AbstractCreatableProvider,
+  AccountPathZod,
   Actor,
   ActorConfigContext,
   ActorConfigZod,