@xyo-network/xl1-protocol-sdk 1.30.4 → 2.0.1

package/dist/neutral/index.mjs

@@ -339,6 +339,14 @@ var BoundWitnessHydrator = class {
     const [hydrated] = await this.hydrateInternal(input, maxDepth, minDepth);
     return hydrated;
   }
+  /**
+   * Like hydrateWithProvenance, but queries every datalake for every hash and returns the full
+   * list of sources per hash. Bypasses the single-source LRU caches so that a prior first-found
+   * cache hit cannot suppress discovery of additional sources.
+   */
+  async hydrateWithAllProvenance(input, maxDepth = 1, minDepth = maxDepth) {
+    return await this.hydrateInternalAll(input, maxDepth, minDepth);
+  }
   async hydrateWithProvenance(input, maxDepth = 1, minDepth = maxDepth) {
     return await this.hydrateInternal(input, maxDepth, minDepth);
   }
@@ -353,6 +361,13 @@ var BoundWitnessHydrator = class {
       return void 0;
     }
   }
+  async tryHydrateWithAllProvenance(input, maxDepth = 1) {
+    try {
+      return await this.hydrateWithAllProvenance(input, maxDepth);
+    } catch {
+      return void 0;
+    }
+  }
   async tryHydrateWithProvenance(input, maxDepth = 1) {
     try {
       return await this.hydrateWithProvenance(input, maxDepth);
@@ -373,6 +388,19 @@ var BoundWitnessHydrator = class {
       orderedPayloads.push(p);
     }
   }
+  async appendDirectPayloadsAll(bw, sources, minDepth, orderedHashes, orderedPayloads) {
+    const fetched = await this.fetchByHashesAll(bw.payload_hashes, sources);
+    if (minDepth >= 1) {
+      const missing = bw.payload_hashes.filter((h) => !fetched.has(h));
+      assertEx4(missing.length === 0, () => `Unable to find all payloads for BoundWitness: missing ${missing.join(", ")}`);
+    }
+    for (const h of bw.payload_hashes) {
+      const p = fetched.get(h);
+      if (isUndefined3(p) || orderedHashes.has(h)) continue;
+      orderedHashes.add(h);
+      orderedPayloads.push(p);
+    }
+  }
   async appendNestedPayloads(sources, minDepth, orderedHashes, orderedPayloads) {
     const nestedHashes = [];
     for (const p of orderedPayloads) {
@@ -393,6 +421,26 @@ var BoundWitnessHydrator = class {
       orderedPayloads.push(p);
     }
   }
+  async appendNestedPayloadsAll(sources, minDepth, orderedHashes, orderedPayloads) {
+    const nestedHashes = [];
+    for (const p of orderedPayloads) {
+      if (!this.isNestedBoundWitness(p)) continue;
+      for (const h of p.payload_hashes) {
+        if (!orderedHashes.has(h)) nestedHashes.push(h);
+      }
+    }
+    const fetched = await this.fetchByHashesAll(nestedHashes, sources);
+    if (minDepth >= 2) {
+      const missing = nestedHashes.filter((h) => !fetched.has(h));
+      assertEx4(missing.length === 0, () => `Unable to find all nested payloads for BoundWitness: missing ${missing.join(", ")}`);
+    }
+    for (const h of nestedHashes) {
+      const p = fetched.get(h);
+      if (isUndefined3(p) || orderedHashes.has(h)) continue;
+      orderedHashes.add(h);
+      orderedPayloads.push(p);
+    }
+  }
   async fetchByHash(hash, sources) {
     const cached = this.payloadCache.get(hash);
     if (isDefined(cached)) {
@@ -430,6 +478,22 @@ var BoundWitnessHydrator = class {
     }
     return result;
   }
+  /**
+   * Exhaustive variant: bypasses both LRU caches and queries every datalake. The picked payload
+   * (locations[0].payload) is the first in registration order; the DataLakeViewer's content-addressed
+   * fetch guarantees all entries for a given hash are equivalent.
+   */
+  async fetchByHashesAll(hashes, sources) {
+    const result = /* @__PURE__ */ new Map();
+    if (hashes.length === 0) return result;
+    const located = await this.locator.findAll(hashes);
+    for (const [h, locations] of located) {
+      if (locations.length === 0) continue;
+      result.set(h, locations[0].payload);
+      sources.set(h, locations);
+    }
+    return result;
+  }
   async hydrateInternal(input, maxDepth, minDepth) {
     assertEx4(maxDepth >= 0 && maxDepth <= 2, () => `maxDepth must be 0, 1, or 2 (got ${maxDepth})`);
     assertEx4(minDepth >= 0 && minDepth <= 2, () => `minDepth must be 0, 1, or 2 (got ${minDepth})`);
@@ -447,6 +511,23 @@ var BoundWitnessHydrator = class {
     }
     return [this.asHydrated([bw, orderedPayloads], true), sources];
   }
+  async hydrateInternalAll(input, maxDepth, minDepth) {
+    assertEx4(maxDepth >= 0 && maxDepth <= 2, () => `maxDepth must be 0, 1, or 2 (got ${maxDepth})`);
+    assertEx4(minDepth >= 0 && minDepth <= 2, () => `minDepth must be 0, 1, or 2 (got ${minDepth})`);
+    assertEx4(maxDepth >= minDepth, () => `maxDepth (${maxDepth}) must be >= minDepth (${minDepth})`);
+    const sources = /* @__PURE__ */ new Map();
+    const bw = await this.resolveBoundWitnessAll(input, sources);
+    if (maxDepth === 0) {
+      return [this.asHydrated([bw, []], true), sources];
+    }
+    const orderedHashes = /* @__PURE__ */ new Set();
+    const orderedPayloads = [];
+    await this.appendDirectPayloadsAll(bw, sources, minDepth, orderedHashes, orderedPayloads);
+    if (maxDepth === 2) {
+      await this.appendNestedPayloadsAll(sources, minDepth, orderedHashes, orderedPayloads);
+    }
+    return [this.asHydrated([bw, orderedPayloads], true), sources];
+  }
   async resolveBoundWitness(input, sources) {
     if (typeof input === "string") {
       const fetched = assertEx4(
@@ -458,6 +539,18 @@ var BoundWitnessHydrator = class {
     const withMeta = "_hash" in input ? input : await PayloadBuilder2.addStorageMeta(input);
     return this.asBoundWitness(withMeta, true);
   }
+  async resolveBoundWitnessAll(input, sources) {
+    if (typeof input === "string") {
+      const fetched = await this.fetchByHashesAll([input], sources);
+      const payload = assertEx4(
+        fetched.get(input),
+        () => `BoundWitness ${input} not found in any datalake`
+      );
+      return this.asBoundWitness(payload, true);
+    }
+    const withMeta = "_hash" in input ? input : await PayloadBuilder2.addStorageMeta(input);
+    return this.asBoundWitness(withMeta, true);
+  }
 };
 
 // src/block/hydrate/createBlockHydrator.ts
@@ -477,12 +570,12 @@ import {
   PayloadZod,
   WithStorageMetaZod
 } from "@xyo-network/sdk-js";
-import { z } from "zod";
+import { z } from "zod/mini";
 var BoundWitnessWithStorageMetaZod = WithStorageMetaZod(BoundWitnessZod);
 var asBoundWitnessWithStorageMeta = zodAsFactory(BoundWitnessWithStorageMetaZod, "asBoundWitnessWithStorageMeta");
 var HydratedBoundWitnessWithStorageMetaZod = z.tuple([
   BoundWitnessWithStorageMetaZod,
-  z.array(WithStorageMetaZod(PayloadZod).loose())
+  z.array(z.looseObject(WithStorageMetaZod(PayloadZod).shape))
 ]);
 var asHydratedBoundWitnessWithStorageMeta = zodAsFactory(
   HydratedBoundWitnessWithStorageMetaZod,
@@ -1147,21 +1240,21 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry12, z as z17 } from "zod";
+import { globalRegistry as globalRegistry12, z as z17 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z16 } from "zod";
+import { z as z16 } from "zod/mini";
 
 // src/config/Chain.ts
 import { AddressZod, HexZod } from "@xylabs/sdk-js";
-import { globalRegistry, z as z2 } from "zod";
+import { globalRegistry, z as z2 } from "zod/mini";
 var ChainConfigZod = z2.object({
-  id: HexZod.optional().register(globalRegistry, {
+  id: z2.optional(HexZod).register(globalRegistry, {
     description: "The unique identifier for the chain. Should be the staking contract address for contract-backed chains.",
     title: "chain.id",
     type: "string"
   }),
-  genesisRewardAddress: AddressZod.optional().register(globalRegistry, {
+  genesisRewardAddress: z2.optional(AddressZod).register(globalRegistry, {
     description: "Address to send the initial genesis rewards to, if a new chain is being created.",
     title: "chain.genesisRewardAddress",
     type: "Address"
@@ -2341,38 +2434,28 @@ var ValidationConfigZod = z15.object({
 
 // src/config/Base.ts
 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"),
-  log: LogConfigZod.default(LogConfigZod.parse({})).describe("Configuration for logging"),
-  providers: ProvidersConfigZod.default(ProvidersConfigZod.parse([])).describe("Configuration for providers"),
-  remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe("Configuration for remote services"),
-  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe("Configuration for the storage"),
-  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe("Configuration for telemetry"),
-  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe("Configuration for validation")
+  chain: z16._default(ChainConfigZod, ChainConfigZod.parse({})).check(z16.describe("Configuration for the chain")),
+  dataLake: z16.optional(DataLakeConfigZod).check(z16.describe("Configuration for data lakes")),
+  evm: z16._default(EvmConfigZod, EvmConfigZod.parse({})).check(z16.describe("Configuration for EVM-backed services")),
+  log: z16._default(LogConfigZod, LogConfigZod.parse({})).check(z16.describe("Configuration for logging")),
+  providers: z16._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z16.describe("Configuration for providers")),
+  remote: z16._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z16.describe("Configuration for remote services")),
+  storage: z16._default(StorageConfigZod, StorageConfigZod.parse({})).check(z16.describe("Configuration for the storage")),
+  telemetry: z16._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z16.describe("Configuration for telemetry")),
+  validation: z16._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z16.describe("Configuration for validation"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z17.string().regex(
+var AccountPathZod = z17.string().check(z17.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({
+));
+var ActorConfigZod = z17.extend(BaseConfigZod, {
   name: z17.string(),
-  accountPath: AccountPathZod.optional().register(globalRegistry12, {
+  accountPath: z17.optional(AccountPathZod).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"
-  }),
-  /**
-   * @deprecated Use the top-level `healthCheckPort` on `ConfigZod` instead.
-   * The system-wide health server covers all actors in a single process; per-actor
-   * health ports will be removed in a future major release.
-   */
-  healthCheckPort: z17.coerce.number().optional().register(globalRegistry12, {
-    description: "[DEPRECATED \u2014 use top-level healthCheckPort] Per-actor health server port.",
-    title: "actor.healthCheckPort",
-    type: "number"
   })
 });
 var isActorConfig = zodIsFactory2(ActorConfigZod);
@@ -2380,24 +2463,31 @@ var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-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([]);
+import { z as z18 } from "zod/mini";
+var ActorsConfigZod = z18._default(
+  z18.array(z18.looseObject(ActorConfigZod.shape)).check(z18.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+  []
+);
 
 // src/config/Config.ts
-import { globalRegistry as globalRegistry13, z as z19 } from "zod";
-var ConfigZod = BaseConfigZod.extend({
+import { globalRegistry as globalRegistry13, z as z19 } from "zod/mini";
+var ConfigZod = z19.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z19.coerce.number().optional().register(globalRegistry13, {
+  healthCheckPort: z19.optional(z19.coerce.number()).register(globalRegistry13, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
+}).check(z19.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 function resolveConfig(config) {
   const parsedConfig = ConfigZod.parse(config);
-  const { actors, ...rootConfig } = parsedConfig;
+  const {
+    actors,
+    healthCheckPort: _healthCheckPort,
+    ...rootConfig
+  } = parsedConfig;
   parsedConfig.actors = actors.map((actorConfig) => {
-    return ActorConfigZod.loose().parse({ ...rootConfig, ...actorConfig });
+    return z19.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
   });
   return parsedConfig;
 }
@@ -2408,15 +2498,15 @@ import {
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry14, z as z20 } from "zod";
-var HostActorConfigZod = ActorConfigZod.extend({
-  host: z20.string().default("localhost").register(globalRegistry14, {
+import { globalRegistry as globalRegistry14, z as z20 } from "zod/mini";
+var HostActorConfigZod = z20.extend(ActorConfigZod, {
+  host: z20._default(z20.string(), "localhost").register(globalRegistry14, {
     default: "localhost",
     description: "Host for the Actor",
     title: "host",
     type: "string"
   }),
-  port: z20.coerce.number().default(8080).register(globalRegistry14, {
+  port: z20._default(z20.coerce.number(), 8080).register(globalRegistry14, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -2464,6 +2554,7 @@ import {
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
+import { z as z23 } from "zod/mini";
 
 // src/model/CreatableProviderContext.zod.ts
 import {
@@ -2472,17 +2563,17 @@ import {
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z22 } from "zod";
+import { z as z22 } from "zod/mini";
 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));
-var BaseConfigContextZod = CachingContextZod.extend({
-  config: BaseConfigZod.loose(),
-  locator: ProviderFactoryLocatorZod.optional()
+var BaseConfigContextZod = z22.extend(CachingContextZod, {
+  config: z22.looseObject(BaseConfigZod.shape),
+  locator: z22.optional(ProviderFactoryLocatorZod)
 });
-var CreatableProviderContextZod = z22.lazy(() => BaseConfigContextZod.extend({
-  _id: z22.string().optional(),
+var CreatableProviderContextZod = z22.lazy(() => z22.extend(BaseConfigContextZod, {
+  _id: z22.optional(z22.string()),
   locator: ProviderFactoryLocatorZod,
-  statusReporter: RuntimeStatusMonitorZod.optional()
+  statusReporter: z22.optional(RuntimeStatusMonitorZod)
 }));
 var isBaseConfigContext = zodIsFactory4(BaseConfigContextZod);
 var asBaseConfigContext = zodAsFactory5(BaseConfigContextZod, "asBaseConfigContext");
@@ -2922,7 +3013,7 @@ var bundle2 = (root, transaction) => {
 };
 
 // src/context/Actor.ts
-var ActorConfigContext = BaseConfigContextZod.extend({ config: ActorConfigZod });
+var ActorConfigContext = z23.extend(BaseConfigContextZod, { config: ActorConfigZod });
 var isActorConfigContext = zodIsFactory5(ActorConfigContext);
 var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
 var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
@@ -3312,7 +3403,8 @@ import {
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory6
 } from "@xylabs/sdk-js";
-var HostActorConfigContext = BaseConfigContextZod.extend({ config: HostActorConfigZod });
+import { z as z24 } from "zod/mini";
+var HostActorConfigContext = z24.extend(BaseConfigContextZod, { config: HostActorConfigZod });
 var isHostActorConfigContext = zodIsFactory6(HostActorConfigContext);
 var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActorConfigContext");
 var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
@@ -3353,26 +3445,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z24 } from "zod";
+import { z as z26 } 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 z25 } from "zod";
+var TypedDataDomainZod = z25.object({
+  name: z25.string().nullable().optional(),
+  version: z25.string().nullable().optional(),
+  chainId: z25.union([z25.string(), z25.number(), z25.bigint()]).nullable().optional(),
+  verifyingContract: z25.string().nullable().optional(),
+  salt: z25.union([z25.string(), z25.instanceof(Uint8Array)]).nullable().optional()
 });
-var TypedDataFieldZod = z23.object({
-  name: z23.string(),
-  type: z23.string()
+var TypedDataFieldZod = z25.object({
+  name: z25.string(),
+  type: z25.string()
 });
-var TypedDataTypesZod = z23.record(z23.string(), z23.array(TypedDataFieldZod));
-var TypedDataValueZod = z23.record(z23.string(), z23.any());
+var TypedDataTypesZod = z25.record(z25.string(), z25.array(TypedDataFieldZod));
+var TypedDataValueZod = z25.record(z25.string(), z25.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z24.object({
+var EIP712DataPayloadFieldsZod = z26.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -3390,11 +3482,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 z27 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z27.object({
+  address: z27.string(),
   hash: HashZod,
-  signature: z25.string()
+  signature: z27.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -4132,12 +4224,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z26.ZodError;
+  return error instanceof z28.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z26.prettifyError(error);
+  return z28.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -4352,9 +4444,7 @@ SimpleBlockViewer = __decorateClass([
 ], SimpleBlockViewer);
 
 // src/simple/blockReward/SimpleBlockRewardViewer.ts
-import {
-  BlockRewardViewerMoniker
-} from "@xyo-network/xl1-protocol-lib";
+import { BlockRewardViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleBlockRewardViewer = class extends AbstractCreatableProvider {
   moniker = SimpleBlockRewardViewer.defaultMoniker;
   allowedRewardForBlock(block) {
@@ -4508,10 +4598,7 @@ SimpleBlockValidationViewer = __decorateClass([
 import {
   assertEx as assertEx35
 } from "@xylabs/sdk-js";
-import {
-  ChainContractViewerMoniker as ChainContractViewerMoniker2,
-  FinalizationViewerMoniker as FinalizationViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
+import { ChainContractViewerMoniker as ChainContractViewerMoniker2, FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleChainContractViewer = class extends AbstractCreatableProvider {
   moniker = SimpleChainContractViewer.defaultMoniker;
   _finalizationViewer;
@@ -4580,15 +4667,10 @@ var SimpleXyoClient = class {
 };
 
 // src/simple/datalake/RestDataLakeRunner.ts
-import {
-  assertEx as assertEx36,
-  exists as exists6
-} from "@xylabs/sdk-js";
+import { assertEx as assertEx36, exists as exists6 } from "@xylabs/sdk-js";
 import { isAnyPayload as isAnyPayload7, PayloadZodLoose } from "@xyo-network/sdk-js";
-import {
-  DataLakeRunnerMoniker
-} from "@xyo-network/xl1-protocol-lib";
-import z27 from "zod";
+import { DataLakeRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
+import { z as z29 } from "zod/mini";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { FetchClientError, FetchJsonClient } from "@xylabs/fetch";
@@ -4661,7 +4743,7 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.client.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z27.array(PayloadZodLoose).parse(result.data);
+      return z29.array(PayloadZodLoose).parse(result.data);
     } else {
       return [];
     }
@@ -4675,9 +4757,7 @@ RestDataLakeRunner = __decorateClass([
 ], RestDataLakeRunner);
 
 // src/simple/datalake/RestDataLakeViewer.ts
-import {
-  DataLakeViewerMoniker
-} from "@xyo-network/xl1-protocol-lib";
+import { DataLakeViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var RestDataLakeViewer = class extends AbstractRestDataLake {
   moniker = RestDataLakeViewer.defaultMoniker;
 };
@@ -4691,9 +4771,7 @@ RestDataLakeViewer = __decorateClass([
 // src/simple/datalake/SimpleDataLakeRunner.ts
 import { exists as exists7 } from "@xylabs/sdk-js";
 import { isAnyPayload as isAnyPayload9, PayloadBuilder as PayloadBuilder19 } from "@xyo-network/sdk-js";
-import {
-  DataLakeRunnerMoniker as DataLakeRunnerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
+import { DataLakeRunnerMoniker as DataLakeRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 
 // src/simple/datalake/AbstractSimpleDataLake.ts
 import { isAnyPayload as isAnyPayload8 } from "@xyo-network/sdk-js";
@@ -4760,9 +4838,7 @@ SimpleDataLakeRunner = __decorateClass([
 ], SimpleDataLakeRunner);
 
 // src/simple/datalake/SimpleDataLakeViewer.ts
-import {
-  DataLakeViewerMoniker as DataLakeViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
+import { DataLakeViewerMoniker as DataLakeViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleDataLakeViewer = class extends AbstractSimpleDataLake {
   moniker = SimpleDataLakeViewer.defaultMoniker;
 };
@@ -4803,9 +4879,7 @@ SimpleFinalizationRunner = __decorateClass([
 ], SimpleFinalizationRunner);
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
-import {
-  assertEx as assertEx37
-} from "@xylabs/sdk-js";
+import { assertEx as assertEx37 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
   ChainContractViewerMoniker as ChainContractViewerMoniker3,
@@ -5014,10 +5088,7 @@ import {
   assertEx as assertEx39,
   exists as exists8
 } from "@xylabs/sdk-js";
-import {
-  isPayloadBundle,
-  PayloadBuilder as PayloadBuilder21
-} from "@xyo-network/sdk-js";
+import { isPayloadBundle, PayloadBuilder as PayloadBuilder21 } from "@xyo-network/sdk-js";
 import {
   BlockValidationViewerMoniker as BlockValidationViewerMoniker2,
   ChainContractViewerMoniker as ChainContractViewerMoniker4,
@@ -5445,10 +5516,7 @@ import {
   isHash as isHash2
 } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle as isPayloadBundle2 } from "@xyo-network/sdk-js";
-import {
-  MempoolViewerMoniker as MempoolViewerMoniker2,
-  WindowedBlockViewerMoniker
-} from "@xyo-network/xl1-protocol-lib";
+import { MempoolViewerMoniker as MempoolViewerMoniker2, WindowedBlockViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var DEFAULT_MEMPOOL_SELECTION_RATIO = 0.66;
 var DEFAULT_DEMOTION_THRESHOLD = 3;
 var DEFAULT_HANDOUT_STATS_TTL_BLOCKS = 1e3;
@@ -5817,10 +5885,7 @@ var MemoryPermissionsStore = class {
 
 // src/simple/runner/SimpleXyoRunner.ts
 import { PayloadBuilder as PayloadBuilder22 } from "@xyo-network/sdk-js";
-import {
-  MempoolRunnerMoniker as MempoolRunnerMoniker2,
-  XyoRunnerMoniker
-} from "@xyo-network/xl1-protocol-lib";
+import { MempoolRunnerMoniker as MempoolRunnerMoniker2, XyoRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleXyoRunner = class extends AbstractCreatableProvider {
   moniker = SimpleXyoRunner.defaultMoniker;
   _mempoolRunner;
@@ -5895,9 +5960,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
 
 // src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts
 import { isDefined as isDefined20 } from "@xylabs/sdk-js";
-import {
-  StakeEventsViewerMoniker
-} from "@xyo-network/xl1-protocol-lib";
+import { StakeEventsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeEventsViewer.defaultMoniker;
   get positions() {
@@ -6074,13 +6137,10 @@ SimpleStakeTotalsViewer = __decorateClass([
 // src/simple/StakeViewer/SimpleStakeViewer.ts
 import {
   asAddress as asAddress4,
+  assertEx as assertEx43,
   toAddress as toAddress6
 } from "@xylabs/sdk-js";
-import { assertEx as assertEx43 } from "@xylabs/sdk-js";
-import {
-  StakeEventsViewerMoniker as StakeEventsViewerMoniker2,
-  StakeViewerMoniker as StakeViewerMoniker2
-} from "@xyo-network/xl1-protocol-lib";
+import { StakeEventsViewerMoniker as StakeEventsViewerMoniker2, StakeViewerMoniker as StakeViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeViewer.defaultMoniker;
   _chainStakeEventsViewer;
@@ -6442,10 +6502,7 @@ SimpleTransactionValidationViewer = __decorateClass([
 ], SimpleTransactionValidationViewer);
 
 // src/simple/TransactionViewer/SimpleTransactionViewer.ts
-import {
-  assertEx as assertEx46,
-  exists as exists10
-} from "@xylabs/sdk-js";
+import { assertEx as assertEx46, exists as exists10 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema } from "@xyo-network/sdk-js";
 import {
   asSignedHydratedTransactionWithHashMeta,
@@ -6795,8 +6852,8 @@ var getUrl = (host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z as z28 } from "zod";
-var MnemonicStringZod = z28.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+import { z as z30 } from "zod";
+var MnemonicStringZod = z30.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");