@xyo-network/xl1-protocol-sdk 3.0.6 → 3.0.7

package/dist/neutral/test/index.mjs

@@ -1029,10 +1029,10 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry14, z as z19 } from "zod/mini";
+import { globalRegistry as globalRegistry11, z as z16 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z18 } from "zod/mini";
+import { z as z15 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
@@ -1052,148 +1052,129 @@ var ChainConfigZod = z.object({
 });
 
 // src/config/transports/Transport.ts
-import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+import { globalRegistry as globalRegistry3, z as z4 } from "zod";
 
-// src/config/Remote.ts
+// src/config/transports/Mongo.ts
 import { globalRegistry as globalRegistry2, z as z2 } from "zod";
-var RpcRemoteConfigBaseZod = z2.object({
-  protocol: z2.string("http").register(globalRegistry2, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  })
-}).describe("Base configuration for the remote RPC");
-var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z2.string("http").register(globalRegistry2, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z2.string().register(globalRegistry2, {
-    description: "URL for the Chain RPC API",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using Http");
-var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z2.string().register(globalRegistry2, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z2.string().register(globalRegistry2, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z2.string().register(globalRegistry2, {
-    description: "Session ID to use for the postMessage RPC connection",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z2.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z2.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 globalRegistry3, z as z3 } from "zod";
-var MongoConfigZod = z3.object({
+var MongoConfigZod = z2.object({
   // TODO: Create from other arguments
-  connectionString: z3.string().nonempty().optional().register(globalRegistry3, {
+  connectionString: z2.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z3.string().nonempty().optional().register(globalRegistry3, {
+  database: z2.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z3.string().nonempty().optional().register(globalRegistry3, {
+  domain: z2.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z3.string().nonempty().optional().register(globalRegistry3, {
+  password: z2.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z3.string().nonempty().optional().register(globalRegistry3, {
+  username: z2.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
   })
 });
 
-// src/config/storage/driver/S3.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { z as z4 } from "zod";
-var S3BucketConfigZod = z4.object({
-  accessKeyId: z4.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
-  accountId: z4.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
-  bucket: z4.string().nonempty().optional().describe("S3-compatible bucket name"),
-  prefix: z4.string().nonempty().optional().describe("Optional key prefix within the bucket"),
-  readUrl: z4.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
-  secretAccessKey: z4.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
-});
-var S3ConfigZod = z4.object({
-  accessKeyId: z4.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
-  accountId: z4.string().nonempty().optional().describe("Shared account id (default for all buckets; on Cloudflare R2 it forms the endpoint)"),
-  chainState: S3BucketConfigZod.optional().describe("Bucket for the mutable chain state (the head pointer)"),
-  finalized: S3BucketConfigZod.optional().describe("Bucket for the finalized files (blocks, payloads, manifest)"),
-  index: S3BucketConfigZod.optional().describe("Bucket for the chain index (the step-summary families)"),
-  prefix: z4.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
-  secretAccessKey: z4.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
+// src/config/transports/S3.ts
+import { z as z3 } from "zod";
+var S3BucketConfigZod = z3.object({
+  accessKeyId: z3.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
+  accountId: z3.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
+  bucket: z3.string().nonempty().optional().describe("S3-compatible bucket name"),
+  prefix: z3.string().nonempty().optional().describe("Optional key prefix within the bucket"),
+  readUrl: z3.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
+  secretAccessKey: z3.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
 });
 
 // src/config/transports/Transport.ts
-var LmdbTransportConfigZod = z5.object({
-  access: z5.enum(["read", "write"]).optional().register(globalRegistry4, {
+var LmdbTransportConfigZod = z4.object({
+  access: z4.enum(["read", "write"]).optional().register(globalRegistry3, {
     description: "Access mode for this LMDB connection (read or write)",
     title: "transports.lmdb.access",
     type: "string"
   }),
-  root: z5.string().register(globalRegistry4, {
+  root: z4.string().register(globalRegistry3, {
     description: "Root directory for local LMDB storage",
     title: "transports.lmdb.root",
     type: "string"
   }),
-  store: z5.string().optional().register(globalRegistry4, {
+  store: z4.string().optional().register(globalRegistry3, {
     description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
     title: "transports.lmdb.store",
     type: "string"
   }),
-  type: z5.literal("lmdb")
+  type: z4.literal("lmdb")
 }).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z5.object({
-  type: z5.literal("mongo"),
+var MongoTransportConfigZod = z4.object({
+  type: z4.literal("mongo"),
   connectionString: MongoConfigZod.shape.connectionString,
   database: MongoConfigZod.shape.database,
   domain: MongoConfigZod.shape.domain,
   password: MongoConfigZod.shape.password,
   username: MongoConfigZod.shape.username
 }).describe("MongoDB storage transport");
-var RpcTransportConfigZod = HttpRpcRemoteConfigZod.extend({ type: z5.literal("rpc") }).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z5.object({
-  type: z5.literal("rest"),
-  baseUrl: z5.string().register(globalRegistry4, {
+var RpcTransportConfigZod = z4.object({
+  type: z4.literal("rpc"),
+  protocol: z4.string().default("http").register(globalRegistry3, {
+    description: "Protocol for the RPC connection (http or postMessage)",
+    title: "transports.rpc.protocol",
+    type: "string"
+  }),
+  url: z4.string().optional().register(globalRegistry3, {
+    description: "URL for the Chain RPC API (http protocol)",
+    title: "transports.rpc.url",
+    type: "string"
+  }),
+  networkId: z4.string().optional().register(globalRegistry3, {
+    description: "Network ID for the postMessage RPC connection",
+    title: "transports.rpc.networkId",
+    type: "string"
+  }),
+  sessionId: z4.string().optional().register(globalRegistry3, {
+    description: "Session ID for the postMessage RPC connection",
+    title: "transports.rpc.sessionId",
+    type: "string"
+  })
+}).describe("XL1 JSON-RPC transport");
+var RestTransportConfigZod = z4.object({
+  type: z4.literal("rest"),
+  baseUrl: z4.string().register(globalRegistry3, {
     description: "HTTP base URL for REST reads",
     title: "transports.rest.baseUrl",
     type: "string"
   })
 }).describe("HTTP REST read transport");
 var S3TransportConfigZod = S3BucketConfigZod.extend({
-  type: z5.literal("s3"),
-  accessKeyId: z5.string().optional(),
-  accountId: z5.string().optional(),
-  secretAccessKey: z5.string().optional()
+  type: z4.literal("s3"),
+  accessKeyId: z4.string().optional(),
+  accountId: z4.string().optional(),
+  secretAccessKey: z4.string().optional()
 }).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z5.object({
-  type: z5.literal("evm-rpc"),
-  url: z5.string().register(globalRegistry4, {
+var EvmRpcTransportConfigZod = z4.object({
+  type: z4.literal("evm-rpc"),
+  url: z4.string().register(globalRegistry3, {
     description: "EVM JSON-RPC URL",
     title: "transports.evm-rpc.url",
     type: "string"
+  }),
+  chainId: z4.string().optional().register(globalRegistry3, {
+    description: "EVM chain ID for this RPC endpoint; auto-detected from the endpoint when omitted",
+    title: "transports.evm-rpc.chainId",
+    type: "string"
   })
 }).describe("EVM JSON-RPC transport");
-var MemoryTransportConfigZod = z5.object({ type: z5.literal("memory") }).describe("In-process memory transport");
-var TransportConfigZod = z5.discriminatedUnion("type", [
+var MemoryTransportConfigZod = z4.object({ type: z4.literal("memory") }).describe("In-process memory transport");
+var TransportConfigZod = z4.discriminatedUnion("type", [
   LmdbTransportConfigZod,
   MongoTransportConfigZod,
   RpcTransportConfigZod,
@@ -1202,18 +1183,18 @@ var TransportConfigZod = z5.discriminatedUnion("type", [
   EvmRpcTransportConfigZod,
   MemoryTransportConfigZod
 ]);
-var TransportsConfigZod = z5.record(z5.string(), TransportConfigZod).default({});
+var TransportsConfigZod = z4.record(z4.string(), TransportConfigZod).default({});
 
 // src/config/DataLake/DataLake.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry6, z as z7 } from "zod";
+import { globalRegistry as globalRegistry5, z as z6 } from "zod";
 
 // src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry5, z as z6 } from "zod";
-var DataLakeDriverConfigBaseZod = z6.object({
-  driver: z6.string().register(globalRegistry5, {
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+var DataLakeDriverConfigBaseZod = z5.object({
+  driver: z5.string().register(globalRegistry4, {
     description: "Driver for the data lake",
     type: "string"
   })
@@ -1221,76 +1202,45 @@ var DataLakeDriverConfigBaseZod = z6.object({
 
 // src/config/DataLake/RestDataLakeConfig.ts
 var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z7.literal("rest").register(globalRegistry6, {
+  driver: z6.literal("rest").register(globalRegistry5, {
     description: "Driver for the REST data lake",
     type: "string"
   }),
-  url: z7.string().register(globalRegistry6, {
+  url: z6.string().register(globalRegistry5, {
     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 globalRegistry7, z as z8 } from "zod";
-var RouterDataLakeConfigZod = z8.object({
-  driver: z8.literal("router").register(globalRegistry7, {
+import { globalRegistry as globalRegistry6, z as z7 } from "zod";
+var RouterDataLakeConfigZod = z7.object({
+  driver: z7.literal("router").register(globalRegistry6, {
     description: "Driver for the router data lake",
     type: "string"
   }),
-  children: z8.array(z8.lazy(() => DataLakeConfigZod)).register(globalRegistry7, {
+  children: z7.array(z7.lazy(() => DataLakeConfigZod)).register(globalRegistry6, {
     description: "Child data lake drivers",
     type: "array"
   })
 }).describe("Configuration for the router data lake driver");
 
 // src/config/DataLake/DataLake.ts
-var DataLakeConfigZod = z9.lazy(() => z9.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
-
-// src/config/Evm.ts
-import { globalRegistry as globalRegistry8, z as z10 } from "zod";
-var EvmInfuraConfigZod = z10.object({
-  projectId: z10.string().optional().register(globalRegistry8, {
-    description: "Infura project ID",
-    title: "evm.infura.projectId",
-    type: "string"
-  }),
-  projectSecret: z10.string().optional().register(globalRegistry8, {
-    description: "Infura project secret",
-    title: "evm.infura.projectSecret",
-    type: "string"
-  })
-});
-var EvmJsonRpcConfigZod = z10.object({
-  url: z10.url().optional().register(globalRegistry8, {
-    description: "JSON-RPC URL",
-    title: "evm.jsonRpc.url",
-    type: "string"
-  })
-});
-var EvmConfigZod = z10.object({
-  chainId: z10.string().optional().register(globalRegistry8, {
-    description: "EVM chain ID",
-    title: "evm.chainId",
-    type: "string"
-  }),
-  infura: EvmInfuraConfigZod.optional().describe("Infura Provider configuration"),
-  jsonRpc: EvmJsonRpcConfigZod.optional().describe("JSON-RPC Provider configuration")
-});
+var DataLakeConfigZod = z8.lazy(() => z8.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry9, z as z11 } from "zod";
+import { globalRegistry as globalRegistry7, z as z9 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z11.object({
-  logLevel: z11.enum(LogLevelNames).default("info").register(globalRegistry9, {
+var LogConfigZod = z9.object({
+  logLevel: z9.enum(LogLevelNames).default("info").register(globalRegistry7, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z11.boolean().default(false).register(globalRegistry9, {
+  silent: z9.boolean().default(false).register(globalRegistry7, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1299,23 +1249,23 @@ var LogConfigZod = z11.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry10, z as z12 } from "zod";
-var ProviderBindingConfigZod = z12.object({
-  connection: z12.string().optional().register(globalRegistry10, {
+import { globalRegistry as globalRegistry8, z as z10 } from "zod";
+var ProviderBindingConfigZod = z10.object({
+  connection: z10.string().optional().register(globalRegistry8, {
     description: "Named connection from the top-level connections map",
     title: "providerBindings.connection",
     type: "string"
   }),
-  transport: z12.string().optional().register(globalRegistry10, {
+  transport: z10.string().optional().register(globalRegistry8, {
     description: "Deprecated alias for connection (kept in sync during migration)",
     title: "providerBindings.transport",
     type: "string"
   })
 }).describe("Provider connection binding");
-var ProviderBindingsConfigZod = z12.record(z12.string(), ProviderBindingConfigZod).default({});
+var ProviderBindingsConfigZod = z10.record(z10.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z14 from "zod";
+import z12 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -1323,55 +1273,43 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z13 } from "zod";
-var ProviderConfigZod = z13.object({
-  moniker: z13.string(),
-  labels: z13.array(z13.string()).optional()
+import { z as z11 } from "zod";
+var ProviderConfigZod = z11.object({
+  moniker: z11.string(),
+  labels: z11.array(z11.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 = z14.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
-
-// src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry11, z as z15 } from "zod";
-var StorageConfigZod = z15.object({
-  mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z15.string().optional().register(globalRegistry11, {
-    description: "Root directory for local storage",
-    title: "storage.root",
-    type: "string"
-  }),
-  s3: S3ConfigZod.optional().describe("Configuration for S3-compatible object storage (e.g. Cloudflare R2)")
-}).describe("Storage configuration options");
+var ProvidersConfigZod = z12.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry12, z as z16 } from "zod";
-var MetricsScrapeConfigZod = z16.object({
-  path: z16.string().default("/metrics").register(globalRegistry12, {
+import { globalRegistry as globalRegistry9, z as z13 } from "zod";
+var MetricsScrapeConfigZod = z13.object({
+  path: z13.string().default("/metrics").register(globalRegistry9, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z16.coerce.number().int().positive().optional().register(globalRegistry12, {
-    description: "Port for the metrics scrape endpoint",
+  port: z13.coerce.number().int().nonnegative().optional().register(globalRegistry9, {
+    description: "Port for the metrics scrape endpoint (0 disables the scrape endpoint)",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z16.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z16.object({
+var MetricsConfigZod = z13.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z13.object({
   // OpenTelemetry options
-  otlpEndpoint: z16.url().optional().register(globalRegistry12, {
+  otlpEndpoint: z13.url().optional().register(globalRegistry9, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z16.object({
+var TelemetryConfigZod = z13.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -1380,14 +1318,14 @@ var TelemetryConfigZod = z16.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
-import { globalRegistry as globalRegistry13, z as z17 } from "zod";
+import { globalRegistry as globalRegistry10, z as z14 } from "zod";
 
 // src/primitives/block/rate/blockRate.ts
-import { isDefined as isDefined7, isFalsy } from "@xylabs/sdk-js";
+import { isDefined as isDefined5, isFalsy } from "@xylabs/sdk-js";
 import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
 
 // src/primitives/block/rate/timeHelpers.ts
-import { assertEx as assertEx10, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, isDefined as isDefined4 } from "@xylabs/sdk-js";
 var rateMultipliers = {
   millis: 1,
   seconds: 1e3,
@@ -1405,7 +1343,7 @@ var timeDurations = (timeInMs) => ({
   weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
 });
 var getTimeConfigInMilliseconds = (timeConfig) => {
-  const assertedTimeConfig = assertEx10(isDefined6(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
+  const assertedTimeConfig = assertEx10(isDefined4(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
   let totalMilliseconds = 0;
   if ("years" in assertedTimeConfig) {
     totalMilliseconds += assertedTimeConfig.years * 31536e6;
@@ -1444,13 +1382,13 @@ var blockRate = (startBlock, endBlock, timeUnit) => {
     throw new Error("Time difference must be greater than 0");
   }
   const rate = heightDifference / timeDifference;
-  const timeUnitValue = isDefined7(timeUnit) ? timeUnit : "millis";
-  const returnedTimeDifference = isDefined7(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timeUnitValue = isDefined5(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined5(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
   const timePerBlock = returnedTimeDifference / heightDifference;
   return {
     range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
     span: heightDifference,
-    rate: isDefined7(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    rate: isDefined5(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
     timeUnit: timeUnitValue,
     timeDifference: returnedTimeDifference,
     timePerBlock
@@ -1498,7 +1436,7 @@ var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit
 // src/primitives/block/rate/timeRate.ts
 import {
   assertEx as assertEx12,
-  isDefined as isDefined8,
+  isDefined as isDefined6,
   isDefinedNotNull
 } from "@xylabs/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber7, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
@@ -1537,7 +1475,7 @@ var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBl
   }
   const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
   const resolvedEndBlock = assertEx12(
-    isDefined8(endBlock?.[0]) ? endBlock[0] : void 0,
+    isDefined6(endBlock?.[0]) ? endBlock[0] : void 0,
     () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
   );
   const endBlockEpoch = resolvedEndBlock.$epoch;
@@ -1620,24 +1558,24 @@ var DEFAULT_MIN_CANDIDATES = 1;
 var DEFAULT_BACKOFF_MS = 12e4;
 
 // src/config/Validation.ts
-var ValidationConfigZod = z17.object({
-  allowedRewardRedeemers: z17.array(XyoAddressZod2).optional().register(globalRegistry13, {
+var ValidationConfigZod = z14.object({
+  allowedRewardRedeemers: z14.array(XyoAddressZod2).optional().register(globalRegistry10, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z17.array(XyoAddressZod2).optional().register(globalRegistry13, {
+  allowedRewardEscrowAccountSigners: z14.array(XyoAddressZod2).optional().register(globalRegistry10, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z17.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry13, {
+  minCandidates: z14.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry10, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z17.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry13, {
+  backoffMs: z14.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry10, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -1646,29 +1584,25 @@ var ValidationConfigZod = z17.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z18.object({
-  chain: z18._default(ChainConfigZod, ChainConfigZod.parse({})).check(z18.describe("Configuration for the chain")),
-  dataLake: z18.optional(DataLakeConfigZod).check(z18.describe("Configuration for data lakes")),
-  evm: z18._default(EvmConfigZod, EvmConfigZod.parse({})).check(z18.describe("Configuration for EVM-backed services")),
-  log: z18._default(LogConfigZod, LogConfigZod.parse({})).check(z18.describe("Configuration for logging")),
-  connections: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
-  providerBindings: z18._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z18.describe("Per-moniker provider connection bindings")),
-  providers: z18._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z18.describe("Configuration for providers")),
-  remote: z18._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z18.describe("Configuration for remote services")),
-  transports: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Deprecated alias for connections (kept in sync during migration)")),
-  storage: z18._default(StorageConfigZod, StorageConfigZod.parse({})).check(z18.describe("Configuration for the storage")),
-  telemetry: z18._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z18.describe("Configuration for telemetry")),
-  validation: z18._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z18.describe("Configuration for validation"))
+var BaseConfigZod = z15.object({
+  chain: z15._default(ChainConfigZod, ChainConfigZod.parse({})).check(z15.describe("Configuration for the chain")),
+  dataLake: z15.optional(DataLakeConfigZod).check(z15.describe("Configuration for data lakes")),
+  log: z15._default(LogConfigZod, LogConfigZod.parse({})).check(z15.describe("Configuration for logging")),
+  connections: z15._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z15.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  providerBindings: z15._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z15.describe("Per-moniker provider connection bindings")),
+  providers: z15._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z15.describe("Configuration for providers")),
+  telemetry: z15._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z15.describe("Configuration for telemetry")),
+  validation: z15._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z15.describe("Configuration for validation"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z19.string().check(z19.regex(
+var AccountPathZod = z16.string().check(z16.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 = z19.extend(BaseConfigZod, {
-  name: z19.string(),
-  accountPath: z19.optional(AccountPathZod).register(globalRegistry14, {
+var ActorConfigZod = z16.extend(BaseConfigZod, {
+  name: z16.string(),
+  accountPath: z16.optional(AccountPathZod).register(globalRegistry11, {
     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"
@@ -1679,22 +1613,22 @@ var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z20 } from "zod/mini";
-var ActorsConfigZod = z20._default(
-  z20.array(z20.looseObject(ActorConfigZod.shape)).check(z20.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+import { z as z17 } from "zod/mini";
+var ActorsConfigZod = z17._default(
+  z17.array(z17.looseObject(ActorConfigZod.shape)).check(z17.describe("Actor-specific configurations that override the base configuration when the actor is running")),
   []
 );
 
 // src/config/Config.ts
-import { globalRegistry as globalRegistry15, z as z21 } from "zod/mini";
-var ConfigZod = z21.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry12, z as z18 } from "zod/mini";
+var ConfigZod = z18.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z21.optional(z21.coerce.number()).register(globalRegistry15, {
+  healthCheckPort: z18.optional(z18.coerce.number()).register(globalRegistry12, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).check(z21.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z18.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 
 // src/summary/primitives/blocks/blocksMaxStep.ts
 var blocksMaxStep = 3;
@@ -1769,7 +1703,7 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
 import {
   assertEx as assertEx15,
   exists,
-  isUndefined as isUndefined3
+  isUndefined as isUndefined2
 } from "@xylabs/sdk-js";
 import { LruCacheMap as LruCacheMap2 } from "@xyo-network/xl1-driver-memory";
 import {
@@ -1945,7 +1879,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   async blockByNumber(blockNumber) {
     return await this.spanAsync("blockByNumber", async () => {
       const chainContext = await this.getChainContextRead();
-      if (isUndefined3(chainContext.head)) {
+      if (isUndefined2(chainContext.head)) {
         return null;
       }
       return await this.blockByNumberWithContext(chainContext, blockNumber);
@@ -1971,7 +1905,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
       assertEx15(limit > 0, () => "limit must be greater than 0");
       assertEx15(limit <= 100, () => "limit must be less than 100");
       const chainContext = await this.getChainContextRead();
-      if (isUndefined3(chainContext.head)) {
+      if (isUndefined2(chainContext.head)) {
         return [];
       }
       const blocks = [];
@@ -1994,7 +1928,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
         () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
       );
       const chainContext = await this.getChainContextRead();
-      if (isUndefined3(chainContext.head)) {
+      if (isUndefined2(chainContext.head)) {
         return [];
       }
       const start = stepIndex * size;