@xyo-network/xl1-protocol-sdk 1.25.21 → 1.25.23

package/dist/neutral/model/CreatableProviderContext.zod.d.ts

@@ -27,12 +27,7 @@ export declare const BaseConfigContextZod: z.ZodObject<{
                 readonly __address: true;
             }, string>>>;
         }, z.core.$strip>>;
-        dataLake: z.ZodDefault<z.ZodObject<{
-            drivers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-                url: z.ZodString;
-                protocol: z.ZodLiteral<"rest">;
-            }, z.core.$strip>]>>>;
-        }, z.core.$strip>>;
+        dataLake: z.ZodOptional<z.ZodType<import("../config/index.ts").DataLakeConfig, unknown, z.core.$ZodTypeInternals<import("../config/index.ts").DataLakeConfig, unknown>>>;
         evm: z.ZodDefault<z.ZodObject<{
             chainId: z.ZodOptional<z.ZodString>;
             infura: z.ZodOptional<z.ZodObject<{
@@ -115,12 +110,6 @@ export declare const isBaseConfigContext: <T>(value: T) => value is T & {
                 readonly __address: true;
             }) | undefined;
         };
-        dataLake: {
-            drivers?: {
-                url: string;
-                protocol: "rest";
-            }[] | undefined;
-        };
         evm: {
             chainId?: string | undefined;
             infura?: {
@@ -178,6 +167,7 @@ export declare const isBaseConfigContext: <T>(value: T) => value is T & {
                 readonly __address: true;
             })[] | undefined;
         };
+        dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
     };
     logger?: import("@xylabs/sdk-js").Logger | undefined;
     meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -199,12 +189,6 @@ export declare const asBaseConfigContext: {
                     readonly __address: true;
                 }) | undefined;
             };
-            dataLake: {
-                drivers?: {
-                    url: string;
-                    protocol: "rest";
-                }[] | undefined;
-            };
             evm: {
                 chainId?: string | undefined;
                 infura?: {
@@ -262,6 +246,7 @@ export declare const asBaseConfigContext: {
                     readonly __address: true;
                 })[] | undefined;
             };
+            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -282,12 +267,6 @@ export declare const asBaseConfigContext: {
                     readonly __address: true;
                 }) | undefined;
             };
-            dataLake: {
-                drivers?: {
-                    url: string;
-                    protocol: "rest";
-                }[] | undefined;
-            };
             evm: {
                 chainId?: string | undefined;
                 infura?: {
@@ -345,6 +324,7 @@ export declare const asBaseConfigContext: {
                     readonly __address: true;
                 })[] | undefined;
             };
+            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -367,12 +347,6 @@ export declare const toBaseConfigContext: {
                     readonly __address: true;
                 }) | undefined;
             };
-            dataLake: {
-                drivers?: {
-                    url: string;
-                    protocol: "rest";
-                }[] | undefined;
-            };
             evm: {
                 chainId?: string | undefined;
                 infura?: {
@@ -430,6 +404,7 @@ export declare const toBaseConfigContext: {
                     readonly __address: true;
                 })[] | undefined;
             };
+            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;
@@ -450,12 +425,6 @@ export declare const toBaseConfigContext: {
                     readonly __address: true;
                 }) | undefined;
             };
-            dataLake: {
-                drivers?: {
-                    url: string;
-                    protocol: "rest";
-                }[] | undefined;
-            };
             evm: {
                 chainId?: string | undefined;
                 infura?: {
@@ -513,6 +482,7 @@ export declare const toBaseConfigContext: {
                     readonly __address: true;
                 })[] | undefined;
             };
+            dataLake?: import("../config/index.ts").DataLakeConfig | undefined;
         };
         logger?: import("@xylabs/sdk-js").Logger | undefined;
         meterProvider?: import("@opentelemetry/api").MeterProvider | undefined;

package/dist/neutral/model/CreatableProviderContext.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CreatableProviderContext.zod.d.ts","sourceRoot":"","sources":["../../../src/model/CreatableProviderContext.zod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAA;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,eAAO,MAAM,uBAAuB,yDAAwE,CAAA;AAE5G,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,8BAA8B,CAC2C,CAAA;AAE3H,MAAM,MAAM,4BAA4B,GAAG,cAAc,GAAG;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,8BAA8B,CAAA;IACvC,cAAc,CAAC,EAAE,oBAAoB,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,OAAO,CAAC,4BAA4B,CAK3E,CAAA;AAEL,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAE5F,eAAO,MAAM,0BAA0B;;;;;;;;UAvB/B,MAAM;YACJ,UAAU;aACT,8BAA8B;qBACtB,oBAAoB;CAoB4C,CAAA;AACnF,eAAO,MAAM,0BAA0B;;;;;;;;;cAxB/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CAqB0E,CAAA;AACjH,eAAO,MAAM,0BAA0B;;;;;;;;;cAzB/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CAsB0E,CAAA"}
+{"version":3,"file":"CreatableProviderContext.zod.d.ts","sourceRoot":"","sources":["../../../src/model/CreatableProviderContext.zod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAE/D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAA;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,eAAO,MAAM,uBAAuB,yDAAwE,CAAA;AAE5G,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,8BAA8B,CAC2C,CAAA;AAE3H,MAAM,MAAM,4BAA4B,GAAG,cAAc,GAAG;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,8BAA8B,CAAA;IACvC,cAAc,CAAC,EAAE,oBAAoB,CAAA;CACtC,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,eAAO,MAAM,2BAA2B,EAAE,CAAC,CAAC,OAAO,CAAC,4BAA4B,CAK3E,CAAA;AAEL,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAE5F,eAAO,MAAM,0BAA0B;;;;;;;;UAvB/B,MAAM;YACJ,UAAU;aACT,8BAA8B;qBACtB,oBAAoB;CAoB4C,CAAA;AACnF,eAAO,MAAM,0BAA0B;;;;;;;;;cAxB/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CAqB0E,CAAA;AACjH,eAAO,MAAM,0BAA0B;;;;;;;;;cAzB/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;;;;;;;;;cAH/B,MAAM;gBACJ,UAAU;iBACT,8BAA8B;yBACtB,oBAAoB;;CAsB0E,CAAA"}

package/dist/neutral/test/index.mjs

@@ -15,7 +15,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS3 } from "@xyo-network/xl1-protocol";
 
 // src/CreatableProvider/AbstractCreatableProvider.ts
-import { AbstractCreatable, assertEx as assertEx2 } from "@xylabs/sdk-js";
+import {
+  AbstractCreatable,
+  assertEx as assertEx2,
+  IdLogger
+} from "@xylabs/sdk-js";
 
 // src/CreatableProvider/ProviderFactory.ts
 import { assertEx } from "@xylabs/sdk-js";
@@ -109,8 +113,13 @@ var ProviderFactory = class _ProviderFactory {
 var AbstractCreatableProvider = class extends AbstractCreatable {
   dependencies = {};
   _contextCache;
+  _logger;
   get logger() {
-    return this.context.logger ?? super.logger;
+    if (this._logger === void 0) {
+      const providedLogger = this.params.logger ?? this.context.logger;
+      this._logger = providedLogger ? new IdLogger(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null;
+    }
+    return this._logger ?? void 0;
   }
   get meter() {
     return this.context.meterProvider?.getMeter(this.name) ?? super.meter;
@@ -147,6 +156,15 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
       logger: params.logger ?? context.logger
     });
   }
+  async createHandler() {
+    await super.createHandler();
+    if (this.tracer === void 0) {
+      this.logger?.warn("No tracer available in context");
+    }
+    if (this.meter === void 0) {
+      this.logger?.warn("No meter available in context");
+    }
+  }
   async locateAndCreate(moniker) {
     return await this.locator.getInstance(moniker);
   }
@@ -365,7 +383,7 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry12, z as z14 } from "zod";
+import { globalRegistry as globalRegistry12, z as z15 } from "zod";
 
 // src/validation/schema/Mnemonic.ts
 import { z } from "zod";
@@ -375,7 +393,7 @@ var MnemonicStringZod = z.string().transform((s) => s.trim().replaceAll(/\s+/g,
 ).describe("BIP-39 mnemonic string");
 
 // src/config/Base.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/config/Chain.ts
 import { AddressZod, HexZod } from "@xylabs/sdk-js";
@@ -394,64 +412,71 @@ var ChainConfigZod = z2.object({
 });
 
 // src/config/DataLake/DataLake.ts
-import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+import { z as z6 } from "zod";
 
-// src/config/DataLake/RestDataLakeRemoteDriverConfig.ts
+// src/config/DataLake/RestDataLakeConfig.ts
 import { globalRegistry as globalRegistry3, z as z4 } from "zod";
 
-// src/config/DataLake/DataLakeRemoteDriverConfig.ts
+// src/config/DataLake/DataLakeRemoteConfig.ts
 import { globalRegistry as globalRegistry2, z as z3 } from "zod";
-var DataLakeRemoteDriverConfigBaseZod = z3.object({
-  protocol: z3.string().register(globalRegistry2, {
-    description: "Protocol for the data lake driver",
-    type: "string"
-  }),
-  url: z3.string().register(globalRegistry2, {
-    description: "URL for the data lake driver",
+var DataLakeDriverConfigBaseZod = z3.object({
+  driver: z3.string().register(globalRegistry2, {
+    description: "Driver for the data lake",
     type: "string"
   })
-}).describe("Base configuration for a remote data lake driver");
+}).describe("Base configuration for a data lake driver");
 
-// src/config/DataLake/RestDataLakeRemoteDriverConfig.ts
-var RestDataLakeRemoteDriverConfigZod = DataLakeRemoteDriverConfigBaseZod.extend({
-  protocol: z4.literal("rest").register(globalRegistry3, {
-    description: "Protocol for the REST data lake driver",
+// src/config/DataLake/RestDataLakeConfig.ts
+var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
+  driver: z4.literal("rest").register(globalRegistry3, {
+    description: "Driver for the REST data lake",
+    type: "string"
+  }),
+  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/DataLake.ts
-var DataLakeDriverConfigZod = z5.union([RestDataLakeRemoteDriverConfigZod]).describe("Configuration for a data lake driver");
-var DataLakeConfigZod = z5.object({
-  drivers: z5.array(DataLakeDriverConfigZod).optional().register(globalRegistry4, {
-    description: "Configuration for data lake drivers",
+// src/config/DataLake/RouterDataLakeConfig.ts
+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: z5.array(z5.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
+    description: "Child data lake drivers",
     type: "array"
   })
-}).describe("Configuration for data lake drivers");
+}).describe("Configuration for the router data lake driver");
+
+// src/config/DataLake/DataLake.ts
+var DataLakeConfigZod = z6.lazy(() => z6.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5, z as z6 } from "zod";
-var EvmInfuraConfigZod = z6.object({
-  projectId: z6.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: z6.string().optional().register(globalRegistry5, {
+  projectSecret: z7.string().optional().register(globalRegistry5, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z6.object({
-  url: z6.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 = z6.object({
-  chainId: z6.string().optional().register(globalRegistry5, {
+var EvmConfigZod = z7.object({
+  chainId: z7.string().optional().register(globalRegistry5, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -462,17 +487,17 @@ var EvmConfigZod = z6.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6, z as z7 } from "zod";
+import { globalRegistry as globalRegistry6, z as z8 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z7.object({
-  logLevel: z7.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: z7.boolean().default(false).register(globalRegistry6, {
+  silent: z8.boolean().default(false).register(globalRegistry6, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -481,66 +506,66 @@ var LogConfigZod = z7.object({
 });
 
 // src/config/Remote.ts
-import { globalRegistry as globalRegistry7, z as z8 } from "zod";
-var RpcRemoteConfigBaseZod = z8.object({
-  protocol: z8.string("http").register(globalRegistry7, {
+import { globalRegistry as globalRegistry7, z as z9 } from "zod";
+var RpcRemoteConfigBaseZod = z9.object({
+  protocol: z9.string("http").register(globalRegistry7, {
     description: "Protocol for the RPC connection",
     type: "string"
   })
 }).describe("Base configuration for the remote RPC");
 var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z8.string("http").register(globalRegistry7, {
+  protocol: z9.string("http").register(globalRegistry7, {
     description: "Protocol for the RPC connection",
     type: "string"
   }).default("http"),
-  url: z8.string().register(globalRegistry7, {
+  url: z9.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: z8.string().register(globalRegistry7, {
+  protocol: z9.string().register(globalRegistry7, {
     description: "Protocol for the RPC connection",
     type: "string"
   }).default("postMessage"),
-  networkId: z8.string().register(globalRegistry7, {
+  networkId: z9.string().register(globalRegistry7, {
     description: "Network ID to use for the postMessage RPC connection",
     type: "string"
   }),
-  sessionId: z8.string().register(globalRegistry7, {
+  sessionId: z9.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 = z8.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z8.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+var RpcRemoteConfigZod = z9.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z9.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
 
 // src/config/storage/driver/Mongo.ts
 import { isDefined, isUndefined } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry8, z as z9 } from "zod";
-var MongoConfigZod = z9.object({
+import { globalRegistry as globalRegistry8, z as z10 } from "zod";
+var MongoConfigZod = z10.object({
   // TODO: Create from other arguments
-  connectionString: z9.string().nonempty().optional().register(globalRegistry8, {
+  connectionString: z10.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z9.string().nonempty().optional().register(globalRegistry8, {
+  database: z10.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z9.string().nonempty().optional().register(globalRegistry8, {
+  domain: z10.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z9.string().nonempty().optional().register(globalRegistry8, {
+  password: z10.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z9.string().nonempty().optional().register(globalRegistry8, {
+  username: z10.string().nonempty().optional().register(globalRegistry8, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
@@ -548,10 +573,10 @@ var MongoConfigZod = z9.object({
 });
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry9, z as z10 } from "zod";
-var StorageConfigZod = z10.object({
+import { globalRegistry as globalRegistry9, z as z11 } from "zod";
+var StorageConfigZod = z11.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z10.string().optional().register(globalRegistry9, {
+  root: z11.string().optional().register(globalRegistry9, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -559,30 +584,30 @@ var StorageConfigZod = z10.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry10, z as z11 } from "zod";
-var MetricsScrapeConfigZod = z11.object({
-  path: z11.string().default("/metrics").register(globalRegistry10, {
+import { globalRegistry as globalRegistry10, z as z12 } from "zod";
+var MetricsScrapeConfigZod = z12.object({
+  path: z12.string().default("/metrics").register(globalRegistry10, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z11.coerce.number().int().positive().optional().register(globalRegistry10, {
+  port: z12.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 = z11.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z11.object({
+var MetricsConfigZod = z12.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z12.object({
   // OpenTelemetry options
-  otlpEndpoint: z11.url().optional().register(globalRegistry10, {
+  otlpEndpoint: z12.url().optional().register(globalRegistry10, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z11.object({
+var TelemetryConfigZod = z12.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -591,24 +616,24 @@ var TelemetryConfigZod = z11.object({
 
 // src/config/Validation.ts
 import { AddressZod as AddressZod2, asAddress } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry11, z as z12 } from "zod";
-var ValidationConfigZod = z12.object({
-  allowedRewardRedeemers: z12.preprocess((val) => {
+import { globalRegistry as globalRegistry11, z as z13 } from "zod";
+var ValidationConfigZod = z13.object({
+  allowedRewardRedeemers: z13.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z12.array(AddressZod2).optional().register(globalRegistry11, {
+  }, z13.array(AddressZod2).optional().register(globalRegistry11, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   })),
-  allowedRewardEscrowAccountSigners: z12.preprocess((val) => {
+  allowedRewardEscrowAccountSigners: z13.preprocess((val) => {
     if (typeof val === "string") {
       return val.split(",").map((s) => asAddress(s.trim()));
     }
     return val;
-  }, z12.array(AddressZod2).optional().register(globalRegistry11, {
+  }, z13.array(AddressZod2).optional().register(globalRegistry11, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
@@ -616,9 +641,9 @@ var ValidationConfigZod = z12.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z13.object({
+var BaseConfigZod = z14.object({
   chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe("Configuration for the chain"),
-  dataLake: DataLakeConfigZod.default(DataLakeConfigZod.parse({})).describe("Configuration for data lakes"),
+  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"),
   remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe("Configuration for remote services"),
@@ -629,13 +654,13 @@ var BaseConfigZod = z13.object({
 
 // src/config/Actor.ts
 var ActorConfigZod = BaseConfigZod.extend({
-  name: z14.string(),
+  name: z15.string(),
   mnemonic: MnemonicStringZod.optional().register(globalRegistry12, {
     description: "Mnemonic for the Actor wallet",
     title: "mnemonic",
     type: "string"
   }),
-  healthCheckPort: z14.coerce.number().optional().register(globalRegistry12, {
+  healthCheckPort: z15.coerce.number().optional().register(globalRegistry12, {
     description: "Port for the Producer health checks",
     title: "producer.healthCheckPort",
     type: "number"
@@ -646,9 +671,9 @@ var asActorConfig = zodAsFactory(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory(ActorConfigZod, "toActorConfig");
 
 // src/config/Config.ts
-import z15 from "zod";
-var ActorsConfigZod = z15.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
-var ConfigZod = BaseConfigZod.extend(z15.object({ actors: ActorsConfigZod }).describe("Actor-specific configurations that override the base configuration when the actor is running").shape);
+import z16 from "zod";
+var ActorsConfigZod = z16.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
+var ConfigZod = BaseConfigZod.extend(z16.object({ actors: ActorsConfigZod }).describe("Actor-specific configurations that override the base configuration when the actor is running").shape);
 
 // src/block/hydrate/allHashesPresent.ts
 function allHashesPresent(hashes, payloads) {