@xyo-network/xl1-protocol-sdk 3.0.10 → 3.0.12

package/dist/neutral/index.mjs

@@ -1120,30 +1120,11 @@ function factoryBackingsCompatible(declared, available) {
 }
 
 // src/config/normalizeConnectionsConfig.ts
-function normalizeProviderBinding(binding) {
-  const connectionName = binding.connection ?? binding.transport;
-  if (connectionName === void 0 || connectionName === "") {
-    return binding;
-  }
-  return {
-    ...binding,
-    connection: connectionName,
-    transport: connectionName
-  };
-}
-function normalizeProviderBindings(bindings) {
-  const normalized = {};
-  for (const [moniker, binding] of Object.entries(bindings)) {
-    if (binding === void 0) continue;
-    normalized[moniker] = normalizeProviderBinding(binding);
-  }
-  return normalized;
-}
 function normalizeConnectionsConfig(config) {
   return {
     ...config,
     connections: config.connections ?? {},
-    providerBindings: normalizeProviderBindings(config.providerBindings ?? {})
+    providerBindings: config.providerBindings ?? {}
   };
 }
 function hasDeclaredConnectionProfiles(config) {
@@ -1564,7 +1545,7 @@ function bindMoniker(moniker, wanted, bindings, selectedById, candidatesByMonike
 }
 function connectionNameForMoniker(moniker, options) {
   const binding = options.providerBindings?.[moniker];
-  const connectionName = binding?.connection ?? binding?.transport;
+  const connectionName = binding?.connection;
   if (!isDefined4(connectionName) || connectionName === "") {
     throw new UnboundProviderError(moniker);
   }
@@ -1674,7 +1655,7 @@ function needsFromConnectionTypes(config, connectionTypes) {
   const allowed = new Set(connectionTypes);
   const needs = /* @__PURE__ */ new Set();
   for (const [moniker, binding] of Object.entries(config.providerBindings)) {
-    const connectionName = binding?.connection ?? binding?.transport;
+    const connectionName = binding?.connection;
     if (connectionName === void 0 || connectionName === "") {
       continue;
     }
@@ -1707,10 +1688,10 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry11, z as z17 } from "zod/mini";
+import { globalRegistry as globalRegistry9, z as z14 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z16 } from "zod/mini";
+import { z as z13 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
@@ -1729,10 +1710,10 @@ var ChainConfigZod = z2.object({
   })
 });
 
-// src/config/transports/Transport.ts
+// src/config/connections/Connection.ts
 import { globalRegistry as globalRegistry3, z as z5 } from "zod";
 
-// src/config/transports/Mongo.ts
+// src/config/connections/Mongo.ts
 import { globalRegistry as globalRegistry2, z as z3 } from "zod";
 var MongoConfigZod = z3.object({
   // TODO: Create from other arguments
@@ -1763,7 +1744,7 @@ var MongoConfigZod = z3.object({
   })
 });
 
-// src/config/transports/S3.ts
+// src/config/connections/S3.ts
 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)"),
@@ -1774,151 +1755,142 @@ var S3BucketConfigZod = z4.object({
   secretAccessKey: z4.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({
+// src/config/connections/Connection.ts
+var LmdbConnectionConfigZod = z5.object({
   access: z5.enum(["read", "write"]).optional().register(globalRegistry3, {
     description: "Access mode for this LMDB connection (read or write)",
-    title: "transports.lmdb.access",
+    title: "connections.lmdb.access",
     type: "string"
   }),
   root: z5.string().register(globalRegistry3, {
     description: "Root directory for local LMDB storage",
-    title: "transports.lmdb.root",
+    title: "connections.lmdb.root",
     type: "string"
   }),
   store: z5.string().optional().register(globalRegistry3, {
     description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
-    title: "transports.lmdb.store",
+    title: "connections.lmdb.store",
     type: "string"
   }),
   type: z5.literal("lmdb")
-}).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z5.object({
+}).describe("LMDB local storage connection");
+var MongoConnectionConfigZod = z5.object({
   type: z5.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 = z5.object({
+}).describe("MongoDB storage connection");
+var RpcConnectionConfigZod = z5.object({
   type: z5.literal("rpc"),
   protocol: z5.string().default("http").register(globalRegistry3, {
     description: "Protocol for the RPC connection (http or postMessage)",
-    title: "transports.rpc.protocol",
+    title: "connections.rpc.protocol",
     type: "string"
   }),
   url: z5.string().optional().register(globalRegistry3, {
     description: "URL for the Chain RPC API (http protocol)",
-    title: "transports.rpc.url",
+    title: "connections.rpc.url",
     type: "string"
   }),
   networkId: z5.string().optional().register(globalRegistry3, {
     description: "Network ID for the postMessage RPC connection",
-    title: "transports.rpc.networkId",
+    title: "connections.rpc.networkId",
     type: "string"
   }),
   sessionId: z5.string().optional().register(globalRegistry3, {
     description: "Session ID for the postMessage RPC connection",
-    title: "transports.rpc.sessionId",
+    title: "connections.rpc.sessionId",
     type: "string"
   })
-}).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z5.object({
+}).describe("XL1 JSON-RPC connection");
+var RestConnectionConfigZod = z5.object({
   type: z5.literal("rest"),
   baseUrl: z5.string().register(globalRegistry3, {
     description: "HTTP base URL for REST reads",
-    title: "transports.rest.baseUrl",
+    title: "connections.rest.baseUrl",
     type: "string"
   })
-}).describe("HTTP REST read transport");
-var S3TransportConfigZod = S3BucketConfigZod.extend({
+}).describe("HTTP REST read connection");
+var S3ConnectionConfigZod = S3BucketConfigZod.extend({
   type: z5.literal("s3"),
   accessKeyId: z5.string().optional(),
   accountId: z5.string().optional(),
   secretAccessKey: z5.string().optional()
-}).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z5.object({
+}).describe("S3-compatible object storage connection");
+var EvmRpcConnectionConfigZod = z5.object({
   type: z5.literal("evm-rpc"),
   url: z5.string().register(globalRegistry3, {
     description: "EVM JSON-RPC URL",
-    title: "transports.evm-rpc.url",
+    title: "connections.evm-rpc.url",
     type: "string"
   }),
   chainId: z5.string().optional().register(globalRegistry3, {
     description: "EVM chain ID for this RPC endpoint; auto-detected from the endpoint when omitted",
-    title: "transports.evm-rpc.chainId",
+    title: "connections.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", [
-  LmdbTransportConfigZod,
-  MongoTransportConfigZod,
-  RpcTransportConfigZod,
-  RestTransportConfigZod,
-  S3TransportConfigZod,
-  EvmRpcTransportConfigZod,
-  MemoryTransportConfigZod
+}).describe("EVM JSON-RPC connection");
+var MemoryConnectionConfigZod = z5.object({ type: z5.literal("memory") }).describe("In-process memory connection");
+var ConnectionConfigZod = z5.discriminatedUnion("type", [
+  LmdbConnectionConfigZod,
+  MongoConnectionConfigZod,
+  RpcConnectionConfigZod,
+  RestConnectionConfigZod,
+  S3ConnectionConfigZod,
+  EvmRpcConnectionConfigZod,
+  MemoryConnectionConfigZod
 ]);
-var TransportsConfigZod = z5.record(z5.string(), TransportConfigZod).default({});
-
-// src/config/DataLake/DataLake.ts
-import { z as z9 } from "zod";
-
-// src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry5, z as z7 } from "zod";
+var ConnectionsConfigZod = z5.record(z5.string(), ConnectionConfigZod).default({});
 
-// src/config/DataLake/DataLakeRemoteConfig.ts
+// src/config/connections/RpcRemote.ts
 import { globalRegistry as globalRegistry4, z as z6 } from "zod";
-var DataLakeDriverConfigBaseZod = z6.object({
-  driver: z6.string().register(globalRegistry4, {
-    description: "Driver for the data lake",
+var RpcRemoteConfigBaseZod = z6.object({
+  protocol: z6.string("http").register(globalRegistry4, {
+    description: "Protocol for the RPC connection",
     type: "string"
   })
-}).describe("Base configuration for a data lake driver");
-
-// src/config/DataLake/RestDataLakeConfig.ts
-var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z7.literal("rest").register(globalRegistry5, {
-    description: "Driver for the REST data lake",
+}).describe("Base configuration for the remote RPC");
+var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z6.string("http").register(globalRegistry4, {
+    description: "Protocol for the RPC connection",
     type: "string"
-  }),
-  url: z7.string().register(globalRegistry5, {
-    description: "URL for the REST data lake",
+  }).default("http"),
+  url: z6.string().register(globalRegistry4, {
+    description: "URL for the Chain RPC API",
     type: "string"
   })
-}).describe("Configuration for the REST data lake driver");
-
-// src/config/DataLake/RouterDataLakeConfig.ts
-import { globalRegistry as globalRegistry6, z as z8 } from "zod";
-var RouterDataLakeConfigZod = z8.object({
-  driver: z8.literal("router").register(globalRegistry6, {
-    description: "Driver for the router data lake",
+}).describe("Configuration for the remote RPC using Http");
+var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z6.string().register(globalRegistry4, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("postMessage"),
+  networkId: z6.string().register(globalRegistry4, {
+    description: "Network ID to use for the postMessage RPC connection",
     type: "string"
   }),
-  children: z8.array(z8.lazy(() => DataLakeConfigZod)).register(globalRegistry6, {
-    description: "Child data lake drivers",
-    type: "array"
+  sessionId: z6.string().register(globalRegistry4, {
+    description: "Session ID to use for the postMessage RPC connection",
+    type: "string"
   })
-}).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");
+}).describe("Configuration for the remote RPC using postMessage");
+var RpcRemoteConfigZod = z6.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry7, z as z10 } from "zod";
+import { globalRegistry as globalRegistry5, z as z7 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z10.object({
-  logLevel: z10.enum(LogLevelNames).default("info").register(globalRegistry7, {
+var LogConfigZod = z7.object({
+  logLevel: z7.enum(LogLevelNames).default("info").register(globalRegistry5, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z10.boolean().default(false).register(globalRegistry7, {
+  silent: z7.boolean().default(false).register(globalRegistry5, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1927,23 +1899,18 @@ var LogConfigZod = z10.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry8, z as z11 } from "zod";
-var ProviderBindingConfigZod = z11.object({
-  connection: z11.string().optional().register(globalRegistry8, {
+import { globalRegistry as globalRegistry6, z as z8 } from "zod";
+var ProviderBindingConfigZod = z8.object({
+  connection: z8.string().optional().register(globalRegistry6, {
     description: "Named connection from the top-level connections map",
     title: "providerBindings.connection",
     type: "string"
-  }),
-  transport: z11.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 = z11.record(z11.string(), ProviderBindingConfigZod).default({});
+var ProviderBindingsConfigZod = z8.record(z8.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z13 from "zod";
+import z10 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -1951,20 +1918,20 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z12 } from "zod";
-var ProviderConfigZod = z12.object({
-  moniker: z12.string(),
-  labels: z12.array(z12.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 = zodAsFactory2(ProviderConfigZod, "asProviderConfig");
 var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
 
 // src/config/Providers.ts
-var ProvidersConfigZod = z13.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
+var ProvidersConfigZod = z10.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry9, z as z14 } from "zod";
+import { globalRegistry as globalRegistry7, z as z11 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -1972,29 +1939,29 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z14.object({
-  path: z14.string().default("/metrics").register(globalRegistry9, {
+var MetricsScrapeConfigZod = z11.object({
+  path: z11.string().default("/metrics").register(globalRegistry7, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z14.coerce.number().int().nonnegative().optional().register(globalRegistry9, {
+  port: z11.coerce.number().int().nonnegative().optional().register(globalRegistry7, {
     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 = z14.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z14.object({
+var MetricsConfigZod = z11.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z11.object({
   // OpenTelemetry options
-  otlpEndpoint: z14.url().optional().register(globalRegistry9, {
+  otlpEndpoint: z11.url().optional().register(globalRegistry7, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z14.object({
+var TelemetryConfigZod = z11.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -2003,7 +1970,7 @@ var TelemetryConfigZod = z14.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
-import { globalRegistry as globalRegistry10, z as z15 } from "zod";
+import { globalRegistry as globalRegistry8, z as z12 } from "zod";
 
 // src/primitives/block/range/blockRangeSteps.ts
 import { asXL1BlockNumber as asXL1BlockNumber2, StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
@@ -2921,24 +2888,24 @@ function findUncles(context, finalizedWindowedChain, blocks) {
 }
 
 // src/config/Validation.ts
-var ValidationConfigZod = z15.object({
-  allowedRewardRedeemers: z15.array(XyoAddressZod2).optional().register(globalRegistry10, {
+var ValidationConfigZod = z12.object({
+  allowedRewardRedeemers: z12.array(XyoAddressZod2).optional().register(globalRegistry8, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z15.array(XyoAddressZod2).optional().register(globalRegistry10, {
+  allowedRewardEscrowAccountSigners: z12.array(XyoAddressZod2).optional().register(globalRegistry8, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z15.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry10, {
+  minCandidates: z12.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry8, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z15.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry10, {
+  backoffMs: z12.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry8, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -2947,25 +2914,24 @@ var ValidationConfigZod = z15.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z16.object({
-  chain: z16._default(ChainConfigZod, ChainConfigZod.parse({})).check(z16.describe("Configuration for the chain")),
-  dataLake: z16.optional(DataLakeConfigZod).check(z16.describe("Configuration for data lakes")),
-  log: z16._default(LogConfigZod, LogConfigZod.parse({})).check(z16.describe("Configuration for logging")),
-  connections: z16._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z16.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
-  providerBindings: z16._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z16.describe("Per-moniker provider connection bindings")),
-  providers: z16._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z16.describe("Configuration for providers")),
-  telemetry: z16._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z16.describe("Configuration for telemetry")),
-  validation: z16._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z16.describe("Configuration for validation"))
+var BaseConfigZod = z13.object({
+  chain: z13._default(ChainConfigZod, ChainConfigZod.parse({})).check(z13.describe("Configuration for the chain")),
+  log: z13._default(LogConfigZod, LogConfigZod.parse({})).check(z13.describe("Configuration for logging")),
+  connections: z13._default(ConnectionsConfigZod, ConnectionsConfigZod.parse({})).check(z13.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  providerBindings: z13._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z13.describe("Per-moniker provider connection bindings")),
+  providers: z13._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z13.describe("Configuration for providers")),
+  telemetry: z13._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z13.describe("Configuration for telemetry")),
+  validation: z13._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z13.describe("Configuration for validation"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z17.string().check(z17.regex(
+var AccountPathZod = z14.string().check(z14.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 = z17.extend(BaseConfigZod, {
-  name: z17.string(),
-  accountPath: z17.optional(AccountPathZod).register(globalRegistry11, {
+var ActorConfigZod = z14.extend(BaseConfigZod, {
+  name: z14.string(),
+  accountPath: z14.optional(AccountPathZod).register(globalRegistry9, {
     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"
@@ -2976,22 +2942,22 @@ var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-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")),
+import { z as z15 } from "zod/mini";
+var ActorsConfigZod = z15._default(
+  z15.array(z15.looseObject(ActorConfigZod.shape)).check(z15.describe("Actor-specific configurations that override the base configuration when the actor is running")),
   []
 );
 
 // src/config/Config.ts
-import { globalRegistry as globalRegistry12, z as z19 } from "zod/mini";
-var ConfigZod = z19.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry10, z as z16 } from "zod/mini";
+var ConfigZod = z16.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z19.optional(z19.coerce.number()).register(globalRegistry12, {
+  healthCheckPort: z16.optional(z16.coerce.number()).register(globalRegistry10, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).check(z19.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z16.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 function resolveConfig(config) {
   const parsedConfig = ConfigZod.parse(config);
   const {
@@ -3000,7 +2966,7 @@ function resolveConfig(config) {
     ...rootConfig
   } = parsedConfig;
   parsedConfig.actors = actors.map((actorConfig) => {
-    return z19.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
+    return z16.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
   });
   return parsedConfig;
 }
@@ -3011,15 +2977,15 @@ import {
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry13, z as z20 } from "zod/mini";
-var HostActorConfigZod = z20.extend(ActorConfigZod, {
-  host: z20._default(z20.string(), "localhost").register(globalRegistry13, {
+import { globalRegistry as globalRegistry11, z as z17 } from "zod/mini";
+var HostActorConfigZod = z17.extend(ActorConfigZod, {
+  host: z17._default(z17.string(), "localhost").register(globalRegistry11, {
     default: "localhost",
     description: "Host for the Actor",
     title: "host",
     type: "string"
   }),
-  port: z20._default(z20.coerce.number(), 8080).register(globalRegistry13, {
+  port: z17._default(z17.coerce.number(), 8080).register(globalRegistry11, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -3030,6 +2996,31 @@ var isHostActorConfig = zodIsFactory3(HostActorConfigZod);
 var asHostActorConfig = zodAsFactory4(HostActorConfigZod, "asHostActorConfig");
 var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
 
+// src/config/resolveRestConnectionEndpoint.ts
+import { assertEx as assertEx21, isDefined as isDefined14 } from "@xylabs/sdk-js";
+function asRestConnectionConfig(connection) {
+  if (connection?.type !== "rest") return void 0;
+  return connection;
+}
+function resolveRestConnectionEndpoint(config, moniker) {
+  const normalized = normalizeConnectionsConfig(config);
+  const binding = normalized.providerBindings[moniker];
+  const connectionName = assertEx21(
+    binding?.connection,
+    () => `Provider "${moniker}" has no providerBindings.connection for REST endpoint resolution`
+  );
+  const rest = assertEx21(
+    asRestConnectionConfig(normalized.connections[connectionName]),
+    () => `Connection "${connectionName}" bound to "${moniker}" is not a rest connection`
+  );
+  const { baseUrl } = rest;
+  assertEx21(
+    isDefined14(baseUrl) && baseUrl !== "",
+    () => `Rest connection "${connectionName}" requires baseUrl`
+  );
+  return baseUrl;
+}
+
 // src/config/synthesizeRpcConnectionBindings.ts
 var DEFAULT_RPC_CONNECTION = "default-rpc";
 var RPC_MONIKERS = [
@@ -3056,70 +3047,36 @@ var RPC_MONIKERS = [
 function synthesizeRpcConnectionBindings() {
   const bindings = {};
   for (const moniker of RPC_MONIKERS) {
-    bindings[moniker] = { connection: DEFAULT_RPC_CONNECTION, transport: DEFAULT_RPC_CONNECTION };
+    bindings[moniker] = { connection: DEFAULT_RPC_CONNECTION };
   }
   return bindings;
 }
 
-// src/config/transports/Rpc.ts
-import { globalRegistry as globalRegistry14, z as z21 } from "zod";
-var RpcRemoteConfigBaseZod = z21.object({
-  protocol: z21.string("http").register(globalRegistry14, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  })
-}).describe("Base configuration for the remote RPC");
-var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z21.string("http").register(globalRegistry14, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z21.string().register(globalRegistry14, {
-    description: "URL for the Chain RPC API",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using Http");
-var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z21.string().register(globalRegistry14, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z21.string().register(globalRegistry14, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z21.string().register(globalRegistry14, {
-    description: "Session ID to use for the postMessage RPC connection",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z21.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-
 // src/config/UsageMeta.ts
-import { z as z22 } from "zod";
-var DescriptionSchema = z22.string();
-var TitleSchema = z22.string();
-var JSONSchemaMetaSchema = z22.object({
-  id: z22.string().optional(),
+import { z as z18 } from "zod";
+var DescriptionSchema = z18.string();
+var TitleSchema = z18.string();
+var JSONSchemaMetaSchema = z18.object({
+  id: z18.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z22.boolean().optional()
-}).catchall(z22.unknown());
+  deprecated: z18.boolean().optional()
+}).catchall(z18.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z22.array(z22.union([z22.string(), z22.number(), z22.literal(true), z22.undefined()])).readonly();
+var ChoicesSchema = z18.array(z18.union([z18.string(), z18.number(), z18.literal(true), z18.undefined()])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z22.unknown().optional(),
+  default: z18.unknown().optional(),
   description: DescriptionSchema,
-  group: z22.string().optional(),
-  hidden: z22.boolean().optional(),
+  group: z18.string().optional(),
+  hidden: z18.boolean().optional(),
   title: TitleSchema,
-  type: z22.union([
-    z22.literal("array"),
-    z22.literal("count"),
-    z22.literal("boolean"),
-    z22.literal("number"),
-    z22.literal("string")
+  type: z18.union([
+    z18.literal("array"),
+    z18.literal("count"),
+    z18.literal("boolean"),
+    z18.literal("number"),
+    z18.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -3132,7 +3089,7 @@ import {
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
-import { z as z24 } from "zod/mini";
+import { z as z20 } from "zod/mini";
 
 // src/model/CreatableProviderContext.zod.ts
 import {
@@ -3141,17 +3098,17 @@ import {
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z23 } from "zod/mini";
-var RuntimeStatusMonitorZod = z23.custom((val) => val !== null && val !== void 0 && typeof val === "object");
-var ProviderFactoryLocatorZod = z23.lazy(() => z23.custom((val) => val !== null && val !== void 0 && typeof val === "object" && "context" in val && "registry" in val));
-var BaseConfigContextZod = z23.extend(CachingContextZod, {
-  config: z23.looseObject(BaseConfigZod.shape),
-  locator: z23.optional(ProviderFactoryLocatorZod)
+import { z as z19 } from "zod/mini";
+var RuntimeStatusMonitorZod = z19.custom((val) => val !== null && val !== void 0 && typeof val === "object");
+var ProviderFactoryLocatorZod = z19.lazy(() => z19.custom((val) => val !== null && val !== void 0 && typeof val === "object" && "context" in val && "registry" in val));
+var BaseConfigContextZod = z19.extend(CachingContextZod, {
+  config: z19.looseObject(BaseConfigZod.shape),
+  locator: z19.optional(ProviderFactoryLocatorZod)
 });
-var CreatableProviderContextZod = z23.lazy(() => z23.extend(BaseConfigContextZod, {
-  _id: z23.optional(z23.string()),
+var CreatableProviderContextZod = z19.lazy(() => z19.extend(BaseConfigContextZod, {
+  _id: z19.optional(z19.string()),
   locator: ProviderFactoryLocatorZod,
-  statusReporter: z23.optional(RuntimeStatusMonitorZod)
+  statusReporter: z19.optional(RuntimeStatusMonitorZod)
 }));
 var isBaseConfigContext = zodIsFactory4(BaseConfigContextZod);
 var asBaseConfigContext = zodAsFactory5(BaseConfigContextZod, "asBaseConfigContext");
@@ -3201,7 +3158,7 @@ import { PayloadBundleSchema as PayloadBundleSchema2 } from "@xyo-network/sdk-js
 import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx21, toHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx22, toHex } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload2,
   BoundWitnessBuilder,
@@ -3227,7 +3184,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   const script = Array.from(elevatedHashes, (elevatedHash) => `elevate|${elevatedHash}`);
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx21(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx22(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -3272,7 +3229,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 // src/transaction/confirmSubmittedTransaction.ts
 import {
   delay,
-  isDefined as isDefined14,
+  isDefined as isDefined15,
   isNumber
 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
@@ -3294,7 +3251,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
   let attempts = 0;
   while (true) {
     const tx = await viewer.transaction.byHash(txHash) ?? void 0;
-    if (isDefined14(tx)) {
+    if (isDefined15(tx)) {
       options?.logger?.debug("Transaction confirmed", txHash);
       return tx;
     }
@@ -3312,7 +3269,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
 };
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx22 } from "@xylabs/sdk-js";
+import { assertEx as assertEx23 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload3,
   hydrateTypedBoundWitness,
@@ -3383,7 +3340,7 @@ var tryHydrateElevatedTransaction = async ({ chainMap }, hash) => {
   return void 0;
 };
 var hydrateElevatedTransaction = async (context, hash) => {
-  return assertEx22(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx23(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 };
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -3436,13 +3393,13 @@ function transactionRequiredGas(hydratedTransaction) {
 
 // src/transaction/signTransaction.ts
 import {
-  assertEx as assertEx23,
+  assertEx as assertEx24,
   hexFromArrayBuffer,
   toArrayBuffer
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
 async function signTransaction(tx, account) {
-  assertEx23(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx24(tx.from === account.address, () => "Signer address does not match transaction from address");
   const unsignedTx = structuredClone(tx);
   unsignedTx.addresses = [account.address];
   unsignedTx.previous_hashes = [account.previousHash ?? null];
@@ -3457,7 +3414,7 @@ async function signTransaction(tx, account) {
 }
 
 // src/transaction/TransactionBuilder.ts
-import { assertEx as assertEx24, Base } from "@xylabs/sdk-js";
+import { assertEx as assertEx25, Base } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
 import {
   asXL1BlockNumber as asXL1BlockNumber4,
@@ -3477,9 +3434,9 @@ var TransactionBuilder = class extends Base {
     super(options);
   }
   async build() {
-    const chain = assertEx24(this._chain, () => "Chain must be set before building the transaction");
-    const fees = assertEx24(this._fees, () => "Fees must be set before building the transaction");
-    const blockRange = assertEx24(this._blockRange, () => "Block range must be set before building the transaction");
+    const chain = assertEx25(this._chain, () => "Chain must be set before building the transaction");
+    const fees = assertEx25(this._fees, () => "Fees must be set before building the transaction");
+    const blockRange = assertEx25(this._blockRange, () => "Block range must be set before building the transaction");
     return await buildTransaction(
       chain,
       this._elevatedPayloads,
@@ -3509,7 +3466,7 @@ var TransactionBuilder = class extends Base {
   }
   elevatedPayload(payload) {
     const allowedPayload = isAllowedBlockPayload2(payload) ? payload : void 0;
-    const allowPayloadExists = assertEx24(allowedPayload, () => "Payload must be an AllowedBlockPayload");
+    const allowPayloadExists = assertEx25(allowedPayload, () => "Payload must be an AllowedBlockPayload");
     this._elevatedPayloads.push(allowPayloadExists);
     return this;
   }
@@ -3605,7 +3562,7 @@ var bundle2 = (root, transaction) => {
 };
 
 // src/context/Actor.ts
-var ActorConfigContext = z24.extend(BaseConfigContextZod, { config: ActorConfigZod });
+var ActorConfigContext = z20.extend(BaseConfigContextZod, { config: ActorConfigZod });
 var isActorConfigContext = zodIsFactory5(ActorConfigContext);
 var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
 var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
@@ -3616,8 +3573,8 @@ import {
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory6
 } from "@xylabs/sdk-js";
-import { z as z25 } from "zod/mini";
-var HostActorConfigContext = z25.extend(BaseConfigContextZod, { config: HostActorConfigZod });
+import { z as z21 } from "zod/mini";
+var HostActorConfigContext = z21.extend(BaseConfigContextZod, { config: HostActorConfigZod });
 var isHostActorConfigContext = zodIsFactory6(HostActorConfigContext);
 var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActorConfigContext");
 var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
@@ -3625,7 +3582,7 @@ var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActo
 // src/CreatableProvider/AbstractCreatableProvider.ts
 import {
   AbstractCreatable,
-  assertEx as assertEx25,
+  assertEx as assertEx26,
   IdLogger
 } from "@xylabs/sdk-js";
 var AbstractCreatableProvider = class extends AbstractCreatable {
@@ -3659,9 +3616,9 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
     return factory;
   }
   static async paramsHandler(params = {}) {
-    const context = assertEx25(params.context, () => new Error("Context is required"));
-    const config = assertEx25(context.config, () => new Error("Context config is required"));
-    const locator = assertEx25(context.locator, () => new Error("Context locator is required"));
+    const context = assertEx26(params.context, () => new Error("Context is required"));
+    const config = assertEx26(context.config, () => new Error("Context config is required"));
+    const locator = assertEx26(context.locator, () => new Error("Context locator is required"));
     return await super.paramsHandler({
       ...params,
       statusReporter: params.statusReporter ?? context.statusReporter,
@@ -3704,13 +3661,13 @@ function labeledCreatableProvider() {
 }
 
 // src/createDeclarationPayload.ts
-import { isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { isDefined as isDefined16 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
 import {
   ChainStakeIntentSchema
 } from "@xyo-network/xl1-protocol-lib";
 var createDeclarationIntent = (address, intent, nbf, exp) => {
-  const expiration = isDefined15(exp) ? exp : nbf + 1e4;
+  const expiration = isDefined16(exp) ? exp : nbf + 1e4;
   const payloadBuilder = new PayloadBuilder13({ schema: ChainStakeIntentSchema });
   const builder = payloadBuilder.fields({
     from: address,
@@ -3742,26 +3699,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z27 } from "zod";
+import { z as z23 } from "zod";
 
 // src/eip-712/Types.ts
-import { z as z26 } from "zod";
-var TypedDataDomainZod = z26.object({
-  name: z26.string().nullable().optional(),
-  version: z26.string().nullable().optional(),
-  chainId: z26.union([z26.string(), z26.number(), z26.bigint()]).nullable().optional(),
-  verifyingContract: z26.string().nullable().optional(),
-  salt: z26.union([z26.string(), z26.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 = z26.object({
-  name: z26.string(),
-  type: z26.string()
+var TypedDataFieldZod = z22.object({
+  name: z22.string(),
+  type: z22.string()
 });
-var TypedDataTypesZod = z26.record(z26.string(), z26.array(TypedDataFieldZod));
-var TypedDataValueZod = z26.record(z26.string(), z26.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 = z27.object({
+var EIP712DataPayloadFieldsZod = z23.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -3779,11 +3736,11 @@ import {
   asSchema as asSchema3,
   isPayloadOfZodType as isPayloadOfZodType2
 } from "@xyo-network/sdk-js";
-import { z as z28 } from "zod";
-var EIP712SignaturePayloadFieldsZod = z28.object({
-  address: z28.string(),
+import { z as z24 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z24.object({
+  address: z24.string(),
   hash: HashZod,
-  signature: z28.string()
+  signature: z24.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -3892,9 +3849,9 @@ var toPositiveBigInt = (value) => {
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
 import {
   asHash as asHash4,
-  assertEx as assertEx33,
+  assertEx as assertEx34,
   exists as exists3,
-  isDefined as isDefined16,
+  isDefined as isDefined17,
   ZERO_ADDRESS
 } from "@xylabs/sdk-js";
 import {
@@ -3960,18 +3917,18 @@ var asTransfersStepSummaryWithStorageMeta = AsObjectFactory7.create(isTransfersS
 var balancesMaxStep = 5;
 
 // src/summary/primitives/balances/balancesStepSummaryFromRange.ts
-import { assertEx as assertEx26, spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx27, spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
 import { isAnyPayload as isAnyPayload3 } from "@xyo-network/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber5, StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol-lib";
 async function balancesStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
   const cacheKey = `${range[0]}|${range[1]}`;
   return await withContextCacheResponse(context, "balancesStepSummaryFromRange", cacheKey, async () => {
     return await spanRootAsync2("balancesStepSummaryFromRange", async () => {
-      const [frameHead] = assertEx26(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
+      const [frameHead] = assertEx27(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
       const frameSize = range[1] - range[0] + 1;
       const key = `${frameHead._hash}|${frameSize}`;
       return frameSize === 1 ? await spanRootAsync2(`balancesStepSummaryFromRange.frameSize=1[${key}]`, async () => {
-        const [, payloads] = assertEx26(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
+        const [, payloads] = assertEx27(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
         const balances = {};
         for (const [address, balance] of Object.entries(netBalancesForPayloads(context, payloads))) {
           balances[address] = toSignedBigInt(balance);
@@ -3984,7 +3941,7 @@ async function balancesStepSummaryFromRange(context, semaphores, blockViewer, su
         };
       }, { ...context, timeBudgetLimit: 500 }) : await spanRootAsync2(`balancesStepSummaryFromRange.frameSize>1[${key}]`, async () => {
         const step = StepSizes8.indexOf(asXL1BlockNumber5(frameSize, true));
-        assertEx26(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
+        assertEx27(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
         const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`);
         if (isAnyPayload3(summaryResult)) {
           return summaryResult;
@@ -4027,7 +3984,7 @@ async function balancesStepSummaryFromRange(context, semaphores, blockViewer, su
 }
 
 // src/summary/primitives/balances/balancesSummary.ts
-import { assertEx as assertEx27, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx28, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
 import { asXyoAddress } from "@xyo-network/sdk-js";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3,
@@ -4038,7 +3995,7 @@ import {
 async function balancesSummary(context, semaphores, blockViewer, summaryMap, config) {
   return await spanRootAsync3("balancesSummary", async () => {
     const headHash = isChainQualifiedHeadConfig(config) ? config.head : await blockViewer.currentBlockHash();
-    const [head] = assertEx27(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
+    const [head] = assertEx28(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange7([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange7(
@@ -4061,7 +4018,7 @@ async function balancesSummary(context, semaphores, blockViewer, summaryMap, con
 var blocksMaxStep = 3;
 
 // src/summary/primitives/blocks/blocksStepSummaryFromRange.ts
-import { assertEx as assertEx28, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx29, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
 import { isAnyPayload as isAnyPayload4 } from "@xyo-network/sdk-js";
 import {
   asBlocksStepSummary,
@@ -4076,7 +4033,7 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
   const cacheKey = `${range[0]}|${range[1]}`;
   return await withContextCacheResponse(context, "blocksStepSummaryFromRange", cacheKey, async () => {
     return await spanRootAsync4("blocksStepSummaryFromRange", async () => {
-      const frameHead = assertEx28(
+      const frameHead = assertEx29(
         await blockViewer.blockByNumber(range[1]),
         () => `Block not found for number: ${range[1]}`
       );
@@ -4092,7 +4049,7 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
         };
       } else {
         const step = StepSizes9.indexOf(asXL1BlockNumber6(frameSize, true));
-        assertEx28(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
+        assertEx29(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
         const key = blocksStepSummaryKey(frameHeadHash, frameSize);
         const summaryResult = await summaryMap.get(key);
         if (isAnyPayload4(summaryResult)) {
@@ -4130,7 +4087,7 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
 var schemasMaxStep = 5;
 
 // src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
-import { assertEx as assertEx29 } from "@xylabs/sdk-js";
+import { assertEx as assertEx30 } from "@xylabs/sdk-js";
 import {
   isAnyPayload as isAnyPayload5,
   isBoundWitness as isBoundWitness2,
@@ -4139,11 +4096,11 @@ import {
 } from "@xyo-network/sdk-js";
 import { StepSizes as StepSizes10 } from "@xyo-network/xl1-protocol-lib";
 async function schemasStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
-  const [frameHead] = assertEx29(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
+  const [frameHead] = assertEx30(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
   const frameSize = range[1] - range[0] + 1;
   let result;
   if (frameSize === 1) {
-    const [block, payloads] = assertEx29(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
+    const [block, payloads] = assertEx30(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
     const boundWitnesses = [block, ...payloads.filter((x) => isBoundWitness2(x) && isHashMeta(x))];
     const schemas = {};
     for (const bw of boundWitnesses) {
@@ -4160,7 +4117,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
     });
   } else {
     const step = StepSizes10.indexOf(frameSize);
-    assertEx29(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
+    assertEx30(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
     const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`);
     if (isAnyPayload5(summaryResult)) {
       result = summaryResult;
@@ -4199,7 +4156,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
 }
 
 // src/summary/primitives/schemas/schemasSummary.ts
-import { assertEx as assertEx30, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx31, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4,
   asXL1BlockRange as asXL1BlockRange8,
@@ -4209,7 +4166,7 @@ import {
 async function schemasSummary(context, semaphores, blockViewer, summaryMap, config) {
   return await spanRootAsync5("schemasSummary", async () => {
     const headHash = isChainQualifiedHeadConfig2(config) ? config.head : await blockViewer.currentBlockHash();
-    const [head] = assertEx30(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
+    const [head] = assertEx31(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig2(config) ? config.range : asXL1BlockRange8([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange8(
@@ -4232,7 +4189,7 @@ async function schemasSummary(context, semaphores, blockViewer, summaryMap, conf
 var transfersMaxStep = 4;
 
 // src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx31, spanRootAsync as spanRootAsync6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx32, spanRootAsync as spanRootAsync6 } from "@xylabs/sdk-js";
 import { isAnyPayload as isAnyPayload6 } from "@xyo-network/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber7, StepSizes as StepSizes11 } from "@xyo-network/xl1-protocol-lib";
 function transfersSummaryKey(frameHeadHash, frameSize) {
@@ -4242,11 +4199,11 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
   const cacheKey = `${range[0]}|${range[1]}`;
   return await withContextCacheResponse(context, "transfersStepSummaryFromRange", cacheKey, async () => {
     return await spanRootAsync6("transfersStepSummaryFromRange", async () => {
-      const [frameHead] = assertEx31(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
+      const [frameHead] = assertEx32(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
       const frameSize = range[1] - range[0] + 1;
       let result;
       if (frameSize === 1) {
-        const [, payloads] = assertEx31(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
+        const [, payloads] = assertEx32(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
         const transfers = {};
         for (const [from, toMap] of Object.entries(netTransfersForPayloads(context, payloads))) {
           transfers[from] = transfers[from] ?? {};
@@ -4262,7 +4219,7 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
         };
       } else {
         const step = StepSizes11.indexOf(asXL1BlockNumber7(frameSize, true));
-        assertEx31(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes11.join(", ")}`);
+        assertEx32(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes11.join(", ")}`);
         const key = transfersSummaryKey(frameHead._hash, frameSize);
         const summaryResult = await summaryMap.get(key);
         if (isAnyPayload6(summaryResult)) {
@@ -4313,7 +4270,7 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
 }
 
 // src/summary/primitives/transfers/transfersSummary.ts
-import { assertEx as assertEx32, spanRootAsync as spanRootAsync7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx33, spanRootAsync as spanRootAsync7 } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress2 } from "@xyo-network/sdk-js";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta5,
@@ -4324,7 +4281,7 @@ import {
 async function transfersSummary(context, semaphores, blockViewer, summaryMap, config) {
   return await spanRootAsync7("transferSummary", async () => {
     const headHash = isChainQualifiedHeadConfig3(config) ? config.head : await blockViewer.currentBlockHash();
-    const [head] = assertEx32(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
+    const [head] = assertEx33(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta5(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig3(config) ? config.range : asXL1BlockRange9([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange9(
@@ -4365,8 +4322,8 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params = {}) {
     return {
       ...await super.paramsHandler(params),
-      balancesSummaryMap: assertEx33(params.balancesSummaryMap, () => "balancesSummaryMap is required"),
-      transfersSummaryMap: assertEx33(params.transfersSummaryMap, () => "transfersSummaryMap is required")
+      balancesSummaryMap: assertEx34(params.balancesSummaryMap, () => "balancesSummaryMap is required"),
+      transfersSummaryMap: assertEx34(params.transfersSummaryMap, () => "transfersSummaryMap is required")
     };
   }
   async accountBalance(address, config) {
@@ -4389,11 +4346,11 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
         const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
         const transfers = transferIndexes.map((index) => {
           const hash = block[0].payload_hashes[index];
-          return assertEx33(
+          return assertEx34(
             block[1].find((p) => p._hash === hash),
             () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`
           );
-        }).filter(exists3).filter((t) => t.from === address || isDefined16(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined17(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4422,7 +4379,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
       const head = isChainQualifiedHeadConfig4(config) ? config.head : await this.blockViewer.currentBlockHash();
       const range = isChainQualifiedRangeConfig4(config) ? config.range : asXL1BlockRange10([
         0,
-        assertEx33(
+        assertEx34(
           await this.blockViewer.blockByHash(head),
           () => `Error: Could not find block with hash ${head}`
         )[0].block
@@ -4437,11 +4394,11 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
       const qualifiedRange = qualifiedEntries[0][1][1].range;
       const qualifiedHeadHash = qualifiedEntries[0][1][1].head;
       for (const [_, [__, { range: range2, head: head2 }]] of qualifiedEntries) {
-        assertEx33(
+        assertEx34(
           range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1],
           () => "Inconsistent ranges in qualifiedAccountBalanceHistories"
         );
-        assertEx33(
+        assertEx34(
           head2 === qualifiedHeadHash,
           () => "Inconsistent head hashes in qualifiedAccountBalanceHistories"
         );
@@ -4512,7 +4469,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
     return await this.spanAsync("qualifiedAccountBalanceHistory", async () => {
       const range = asRange(headOrRange);
       const headHash = asHash4(headOrRange);
-      const [head] = assertEx33(isDefined16(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+      const [head] = assertEx34(isDefined17(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
       const startingRange = asXL1BlockRange10(range ?? [0, head.block], true);
       const blockNumbers = await this.distillTransferHistory(address, startingRange);
       const blockResults = await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)));
@@ -4522,11 +4479,11 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
         const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
         const transfers = transferIndexes.map((index) => {
           const hash = block[0].payload_hashes[index];
-          return assertEx33(
+          return assertEx34(
             block[1].find((p) => p._hash === hash),
             () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`
           );
-        }).filter(exists3).filter((t) => t.from === address || isDefined16(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined17(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4554,7 +4511,7 @@ SimpleAccountBalanceViewer = __decorateClass([
 
 // src/simple/block/SimpleBlockViewer.ts
 import {
-  assertEx as assertEx34,
+  assertEx as assertEx35,
   exists as exists4,
   isUndefined as isUndefined7
 } from "@xylabs/sdk-js";
@@ -4595,12 +4552,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z29 } from "zod";
+import { z as z25 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z29.ZodError;
+  return error instanceof z25.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z29.prettifyError(error);
+  return z25.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -4618,7 +4575,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   _headPollTimer = null;
   _signedHydratedBlockCache;
   get finalizedArchivist() {
-    return assertEx34(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
+    return assertEx35(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
   }
   get blocksSummaryMap() {
     this._blocksSummaryMap ??= this.params.blocksSummaryMap ?? new LruCacheMap2({ max: 32 });
@@ -4642,14 +4599,14 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     const headPollIntervalMs = params.headPollIntervalMs;
     if (headPollIntervalMs !== void 0) {
-      assertEx34(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
+      assertEx35(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
     }
     const connection = params.connection;
     const finalizedArchivist = params.finalizedArchivist ?? (connection ? await connectArchivist(connection, { name: CHAIN_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
       blocksSummaryMap: params.blocksSummaryMap,
-      finalizedArchivist: assertEx34(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection"),
+      finalizedArchivist: assertEx35(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection"),
       headPollIntervalMs
     };
   }
@@ -4678,8 +4635,8 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByHash(hash, limit = 50) {
     return await this.spanAsync("blocksByHash", async () => {
-      assertEx34(limit > 0, () => "limit must be greater than 0");
-      assertEx34(limit <= 100, () => "limit must be less than 100");
+      assertEx35(limit > 0, () => "limit must be greater than 0");
+      assertEx35(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -4693,8 +4650,8 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByNumber(blockNumber, limit = 50) {
     return await this.spanAsync("blocksByNumber", async () => {
-      assertEx34(limit > 0, () => "limit must be greater than 0");
-      assertEx34(limit <= 100, () => "limit must be less than 100");
+      assertEx35(limit > 0, () => "limit must be greater than 0");
+      assertEx35(limit <= 100, () => "limit must be less than 100");
       const chainContext = await this.getChainContextRead();
       if (isUndefined7(chainContext.head)) {
         return [];
@@ -4712,9 +4669,9 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByStep(stepLevel, stepIndex) {
     return await this.spanAsync("blocksByStep", async () => {
-      assertEx34(Number.isSafeInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
+      assertEx35(Number.isSafeInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
       const size = stepSize2(stepLevel);
-      assertEx34(
+      assertEx35(
         stepLevel <= blocksMaxStep,
         () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
       );
@@ -4740,7 +4697,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
         const headBlock = await this.finalizationViewer.headBlock();
         return headBlock.chain;
       }
-      const block = assertEx34(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`);
+      const block = assertEx35(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`);
       return block[0].chain;
     }, this.context);
   }
@@ -4876,7 +4833,7 @@ SimpleBlockRewardViewer = __decorateClass([
 ], SimpleBlockRewardViewer);
 
 // src/simple/blockValidation/SimpleBlockValidationViewer.ts
-import { assertEx as assertEx35 } from "@xylabs/sdk-js";
+import { assertEx as assertEx36 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2,
@@ -4932,7 +4889,7 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
     let head;
     if (isChainQualifiedHeadConfig5(config)) {
       const headBlockResult = await this.blockViewer.blockByHash(config.head);
-      head = headBlockResult == null ? assertEx35(
+      head = headBlockResult == null ? assertEx36(
         void 0,
         () => `Specified a head that is not in the chain [${config.head}]`
       ) : headBlockResult[0];
@@ -5020,7 +4977,7 @@ SimpleBlockValidationViewer = __decorateClass([
 ], SimpleBlockValidationViewer);
 
 // src/simple/chainContractViewer/SimpleChainContractViewer.ts
-import { assertEx as assertEx36 } from "@xylabs/sdk-js";
+import { assertEx as assertEx37 } from "@xylabs/sdk-js";
 import { ChainContractViewerMoniker as ChainContractViewerMoniker2, FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleChainContractViewer = class extends AbstractCreatableProvider {
   moniker = SimpleChainContractViewer.defaultMoniker;
@@ -5037,7 +4994,7 @@ var SimpleChainContractViewer = class extends AbstractCreatableProvider {
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
       while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx36(await contractViewer.forkedChainContractViewer());
+        contractViewer = assertEx37(await contractViewer.forkedChainContractViewer());
         forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
         chainId = await contractViewer.chainId();
       }
@@ -5092,15 +5049,17 @@ var SimpleXyoClient = class {
 };
 
 // src/simple/datalake/RestDataLakeRunner.ts
-import { assertEx as assertEx37, exists as exists6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx39, exists as exists6 } from "@xylabs/sdk-js";
 import { isAnyPayload as isAnyPayload8, PayloadZodLoose } from "@xyo-network/sdk-js";
 import { DataLakeRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
-import { z as z30 } from "zod/mini";
+import { z as z26 } from "zod/mini";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { FetchClientError, FetchJsonClient } from "@xylabs/sdk-js";
 import {
-  exists as exists5
+  assertEx as assertEx38,
+  exists as exists5,
+  isDefined as isDefined18
 } from "@xylabs/sdk-js";
 import { asAnyPayload as asAnyPayload4, isAnyPayload as isAnyPayload7 } from "@xyo-network/sdk-js";
 var AbstractRestDataLake = class extends AbstractCreatableProvider {
@@ -5114,7 +5073,18 @@ var AbstractRestDataLake = class extends AbstractCreatableProvider {
     return this.params.disallowedSchemas;
   }
   get endpoint() {
-    return this.params.endpoint;
+    return this.params.endpoint ?? "";
+  }
+  static async paramsHandler(params = {}) {
+    const moniker = this.defaultMoniker;
+    const endpoint = isDefined18(params.endpoint) && params.endpoint !== "" ? params.endpoint : resolveRestConnectionEndpoint(
+      assertEx38(params.context?.config, () => "Context config is required to resolve REST data lake endpoint"),
+      moniker
+    );
+    return {
+      ...await super.paramsHandler(params),
+      endpoint
+    };
   }
   async get(hashes) {
     const results = await Promise.all(hashes.map((hash) => this.getOne(hash)));
@@ -5163,14 +5133,14 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
   async insert(items) {
     const allowedItems = items.map((item) => {
       if (isAnyPayload8(item) && this.isAllowed(item)) {
-        assertEx37(typeof item === "object" && item !== null, () => "Data must be an object");
+        assertEx39(typeof item === "object" && item !== null, () => "Data must be an object");
         return item;
       }
       return null;
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.client.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z30.array(PayloadZodLoose).parse(result.data);
+      return z26.array(PayloadZodLoose).parse(result.data);
     }
     return [];
   }
@@ -5286,13 +5256,13 @@ SimpleDataLakeViewer = __decorateClass([
 ], SimpleDataLakeViewer);
 
 // src/simple/finalization/SimpleFinalizationRunner.ts
-import { assertEx as assertEx38 } from "@xylabs/sdk-js";
+import { assertEx as assertEx40 } from "@xylabs/sdk-js";
 import { FinalizationRunnerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleFinalizationRunner = class extends AbstractCreatableProvider {
   moniker = SimpleFinalizationRunner.defaultMoniker;
   _store;
   get finalizedArchivist() {
-    return assertEx38(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
+    return assertEx40(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
   }
   get store() {
     return this._store;
@@ -5302,7 +5272,7 @@ var SimpleFinalizationRunner = class extends AbstractCreatableProvider {
     const finalizedArchivist = params?.finalizedArchivist ?? (connection ? await connectArchivist(connection, { name: CHAIN_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx38(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection")
+      finalizedArchivist: assertEx40(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection")
     };
   }
   async createHandler() {
@@ -5330,7 +5300,7 @@ SimpleFinalizationRunner = __decorateClass([
 ], SimpleFinalizationRunner);
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
-import { assertEx as assertEx39 } from "@xylabs/sdk-js";
+import { assertEx as assertEx41 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
   ChainContractViewerMoniker as ChainContractViewerMoniker3,
@@ -5342,7 +5312,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   _store;
   _signedHydratedBlockCache;
   get finalizedArchivist() {
-    return assertEx39(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
+    return assertEx41(this.params.finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection");
   }
   get hydratedBlockCache() {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache;
@@ -5361,7 +5331,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     const finalizedArchivist = params.finalizedArchivist ?? (connection ? await connectArchivist(connection, { name: CHAIN_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx39(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection")
+      finalizedArchivist: assertEx41(finalizedArchivist, () => "finalizedArchivist is required \u2014 inject it or bind a connection")
     };
   }
   chainId() {
@@ -5371,18 +5341,18 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     await super.createHandler();
     const finalizedArchivist = this.finalizedArchivist;
     const mostRecentBlock = await findMostRecentBlock(finalizedArchivist);
-    this._chainId = assertEx39(this.config.chain.id ?? mostRecentBlock?.chain, () => "chain.id is required if empty archivist");
+    this._chainId = assertEx41(this.config.chain.id ?? mostRecentBlock?.chain, () => "chain.id is required if empty archivist");
     this._store = { chainMap: finalizedArchivist };
   }
   async head() {
     return await this.spanAsync("head", async () => {
-      const currentHead = assertEx39(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      const currentHead = assertEx41(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
         this.logger?.error(`Could not find current block with hash ${currentHead._hash}`);
       }
-      return assertEx39(block, () => "Could not find current block");
+      return assertEx41(block, () => "Could not find current block");
     }, this.context);
   }
   async headBlock() {
@@ -5412,8 +5382,8 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async getCurrentHead() {
     const chainArchivist = this.finalizedArchivist;
-    const result = assertEx39(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
-    assertEx39(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
+    const result = assertEx41(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
+    assertEx41(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
     return result;
   }
 };
@@ -5445,9 +5415,9 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
 import {
-  assertEx as assertEx40,
+  assertEx as assertEx42,
   BigIntToJsonZod,
-  isDefined as isDefined17
+  isDefined as isDefined19
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/sdk-js";
 import {
@@ -5478,23 +5448,23 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     return this._signer;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx40(this.connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx42(this.connection.viewer, () => "No viewer available on connection");
     const {
       nbf,
       exp,
       chain,
       fees
     } = options ?? {};
-    const resolvedChainId = isDefined17(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber10(isDefined17(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber10(isDefined17(exp) ? exp : resolvedNbf + 10, true);
+    const resolvedChainId = isDefined19(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = asXL1BlockNumber10(isDefined19(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber10(isDefined19(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
     return await this.addTransactionToChain(tx, await PayloadBuilder20.addHashMeta(offChain));
   }
   async addTransactionToChain(tx, offChain = []) {
     const connection = this.connection;
     const signer = this.signer;
-    const runner = assertEx40(connection.runner, () => "No runner available on connection");
+    const runner = assertEx42(connection.runner, () => "No runner available on connection");
     let signedTx;
     if (isSignedHydratedTransaction(tx)) {
       const [bw, payloads] = tx;
@@ -5509,7 +5479,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
   }
   async confirmSubmittedTransaction(txHash, options) {
     return await confirmSubmittedTransaction(
-      assertEx40(this.connection.viewer, () => "Connection viewer is undefined"),
+      assertEx42(this.connection.viewer, () => "Connection viewer is undefined"),
       txHash,
       options
     );
@@ -5548,7 +5518,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
 
 // src/simple/mempool/SimpleMempoolRunner.ts
 import {
-  assertEx as assertEx41,
+  assertEx as assertEx43,
   exists as exists8
 } from "@xylabs/sdk-js";
 import { isPayloadBundle, PayloadBuilder as PayloadBuilder21 } from "@xyo-network/sdk-js";
@@ -5604,10 +5574,10 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     return this.params.maxPendingTransactions ?? 0;
   }
   get pendingBlocksArchivist() {
-    return assertEx41(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection");
+    return assertEx43(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection");
   }
   get pendingTransactionsArchivist() {
-    return assertEx41(this.params.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection");
+    return assertEx43(this.params.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection");
   }
   get syncInterval() {
     return this.params.syncInterval ?? DEFAULT_SYNC_INTERVAL;
@@ -5627,8 +5597,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     const pendingTransactionsArchivist = params?.pendingTransactionsArchivist ?? (connection ? await connectArchivist(connection, { name: PENDING_TRANSACTIONS_ARCHIVIST_ROLE }) : void 0);
     return {
       ...await super.paramsHandler(params),
-      pendingBlocksArchivist: assertEx41(pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection"),
-      pendingTransactionsArchivist: assertEx41(pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection")
+      pendingBlocksArchivist: assertEx43(pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection"),
+      pendingTransactionsArchivist: assertEx43(pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection")
     };
   }
   async createHandler() {
@@ -5667,7 +5637,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         remainingBlockMap.push(i);
         return b;
       }).filter(exists8);
-      assertEx41(
+      assertEx43(
         remainingBlockMap.length === remainingBlocks.length,
         () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`
       );
@@ -5730,7 +5700,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         remainingTransactionMap.push(i);
         return t;
       }).filter(exists8);
-      assertEx41(
+      assertEx43(
         remainingTransactionMap.length === remainingTransactions.length,
         () => `remainingTransactionMap length should match remainingTransactions length [${remainingTransactionMap.length}/${remainingTransactions.length}]`
       );
@@ -5983,9 +5953,9 @@ SimpleMempoolRunner = __decorateClass([
 
 // src/simple/mempool/SimpleMempoolViewer.ts
 import {
-  assertEx as assertEx42,
+  assertEx as assertEx44,
   exists as exists9,
-  isDefined as isDefined18,
+  isDefined as isDefined20,
   isHash as isHash2
 } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle as isPayloadBundle2 } from "@xyo-network/sdk-js";
@@ -6004,10 +5974,10 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     return this.params.handoutStatsTtlBlocks ?? DEFAULT_HANDOUT_STATS_TTL_BLOCKS;
   }
   get pendingBlocksArchivist() {
-    return assertEx42(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection");
+    return assertEx44(this.params.pendingBlocksArchivist, () => "pendingBlocksArchivist is required \u2014 inject it or bind a connection");
   }
   get pendingTransactionsArchivist() {
-    return assertEx42(this.params.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection");
+    return assertEx44(this.params.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required \u2014 inject it or bind a connection");
   }
   get windowedBlockViewer() {
     return this._windowedBlockViewer;
@@ -6056,7 +6026,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingBlocksArchivist.get([providedCursor]);
-      if (isDefined18(p)) {
+      if (isDefined20(p)) {
         cursor = p._sequence;
       }
     }
@@ -6076,7 +6046,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingTransactionsArchivist.get([providedCursor]);
-      if (isDefined18(p)) {
+      if (isDefined20(p)) {
         cursor = p._sequence;
       }
     }
@@ -6149,7 +6119,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     const hydratedResults = await Promise.all(
       filteredBundles.map(async (bundle3) => {
         const tx = await bundledPayloadToHydratedTransaction(bundle3);
-        return isDefined18(tx) ? { bundle: bundle3, tx } : void 0;
+        return isDefined20(tx) ? { bundle: bundle3, tx } : void 0;
       })
     );
     return hydratedResults.filter(exists9);
@@ -6293,7 +6263,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx43 } from "@xylabs/sdk-js";
+import { assertEx as assertEx45 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   invoker;
   _store;
@@ -6302,7 +6272,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx43(this._store, () => "Store must be defined to get permissions");
+    return assertEx45(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -6355,7 +6325,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx44 } from "@xylabs/sdk-js";
+import { assertEx as assertEx46 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   _invoker;
   permissions = [];
@@ -6363,7 +6333,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx44(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx46(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -6455,7 +6425,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
 };
 
 // src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts
-import { isDefined as isDefined19 } from "@xylabs/sdk-js";
+import { isDefined as isDefined21 } from "@xylabs/sdk-js";
 import { StakeEventsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeEventsViewer.defaultMoniker;
@@ -6468,7 +6438,7 @@ var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined19(name)) {
+    if (isDefined21(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -6535,7 +6505,7 @@ SimpleStakeEventsViewer = __decorateClass([
 ], SimpleStakeEventsViewer);
 
 // src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts
-import { assertEx as assertEx45 } from "@xylabs/sdk-js";
+import { assertEx as assertEx47 } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress3 } from "@xyo-network/sdk-js";
 import {
   StakeTotalsViewerMoniker,
@@ -6579,7 +6549,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._stakeViewer = assertEx45(
+    this._stakeViewer = assertEx47(
       await this.locateAndCreate(StakeViewerMoniker),
       () => "Failed to create StakeViewer"
     );
@@ -6635,14 +6605,14 @@ SimpleStakeTotalsViewer = __decorateClass([
 ], SimpleStakeTotalsViewer);
 
 // src/simple/StakeViewer/SimpleStakeViewer.ts
-import { assertEx as assertEx46, toAddress } from "@xylabs/sdk-js";
+import { assertEx as assertEx48, toAddress } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress4 } from "@xyo-network/sdk-js";
 import { StakeEventsViewerMoniker as StakeEventsViewerMoniker2, StakeViewerMoniker as StakeViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeViewer.defaultMoniker;
   _chainStakeEventsViewer;
   get stakeEvents() {
-    return assertEx46(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx48(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get positions() {
     return this.params.positions;
@@ -6682,7 +6652,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._chainStakeEventsViewer = assertEx46(
+    this._chainStakeEventsViewer = assertEx48(
       await this.locateAndCreate(StakeEventsViewerMoniker2),
       () => "Failed to create StakeEventsViewer"
     );
@@ -6717,7 +6687,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     return toAddress(toAddress(1n));
   }
   stakeById(id) {
-    return assertEx46(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx48(this.positions[id], () => new Error(`Stake with id ${id} not found`));
   }
   stakeByStaker(staker, slot) {
     return this.positions.filter((s) => asXyoAddress4(s.staker) === asXyoAddress4(staker))[slot];
@@ -6821,8 +6791,8 @@ RestSyncViewer = __decorateClass([
 // src/simple/timeSync2/SimpleTimeSyncViewer.ts
 import {
   asHash as asHash5,
-  assertEx as assertEx47,
-  isDefined as isDefined20
+  assertEx as assertEx49,
+  isDefined as isDefined22
 } from "@xylabs/sdk-js";
 import {
   asTimePayload as asTimePayload2,
@@ -6843,10 +6813,10 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx47(await this.blockViewer.blockByNumber(asXL1BlockNumber11(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx49(await this.blockViewer.blockByNumber(asXL1BlockNumber11(from, true)), () => "Block not found");
         const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
         const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
-        const timePayload = asTimePayload2(isDefined20(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload2(isDefined22(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -6899,10 +6869,10 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         return [Date.now(), null];
       }
       case "ethereum": {
-        const provider = assertEx47(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx49(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash5(assertEx47(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash5(assertEx49(block?.hash, () => "Block hash not found"), true);
         return [blockNumber, blockHash];
       }
       default: {
@@ -6917,10 +6887,10 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       // this is for the previous block
       xl1,
       // this is for the previous block
-      xl1Hash: assertEx47(xl1Hash, () => "No xl1 hash available from time sync service"),
+      xl1Hash: assertEx49(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
-    if (isDefined20(this.ethProvider)) {
+    if (isDefined22(this.ethProvider)) {
       const [ethereum, ethHashOrNull] = await this.currentTimeAndHash("ethereum");
       const ethereumHash = asHash5(ethHashOrNull, () => "No ethereum hash available from time sync service");
       timePayload.ethereum = ethereum;
@@ -6939,7 +6909,7 @@ SimpleTimeSyncViewer = __decorateClass([
 ], SimpleTimeSyncViewer);
 
 // src/simple/transactionValidation/SimpleTransactionValidationViewer.ts
-import { assertEx as assertEx48 } from "@xylabs/sdk-js";
+import { assertEx as assertEx50 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder24 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
@@ -6993,7 +6963,7 @@ var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider
     let head;
     if (isChainQualifiedHeadConfig6(config)) {
       const headBlockResult = await this.blockViewer.blockByHash(config.head);
-      head = headBlockResult == null ? assertEx48(
+      head = headBlockResult == null ? assertEx50(
         void 0,
         () => `Specified a head that is not in the chain [${config.head}]`
       ) : headBlockResult[0];
@@ -7065,7 +7035,7 @@ SimpleTransactionValidationViewer = __decorateClass([
 ], SimpleTransactionValidationViewer);
 
 // src/simple/TransactionViewer/SimpleTransactionViewer.ts
-import { assertEx as assertEx49, exists as exists10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx51, exists as exists10 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema } from "@xyo-network/sdk-js";
 import {
   asSignedHydratedTransactionWithHashMeta,
@@ -7082,7 +7052,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
   }
   async byBlockHashAndIndex(blockHash, transactionIndex) {
     return await this.spanAsync("byBlockHashAndIndex", async () => {
-      assertEx49(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      assertEx51(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
       try {
         const block = await this.blockViewer.blockByHash(blockHash);
         if (!block) return null;
@@ -7147,7 +7117,7 @@ SimpleTransactionViewer = __decorateClass([
 
 // src/simple/windowedBlock/SimpleWindowedBlockViewer.ts
 import {
-  assertEx as assertEx50,
+  assertEx as assertEx52,
   exists as exists11,
   isNull as isNull2
 } from "@xylabs/sdk-js";
@@ -7229,7 +7199,7 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = assertEx50(
+    this._blockViewer = assertEx52(
       this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker7),
       () => "BlockViewer instance is required"
     );
@@ -7238,13 +7208,13 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     this._transactionHashMap = new MemoryMap2();
   }
   currentBlock() {
-    return assertEx50(this._chain.at(-1));
+    return assertEx52(this._chain.at(-1));
   }
   currentBlockHash() {
-    return assertEx50(this._chain.at(-1)?.[0]._hash);
+    return assertEx52(this._chain.at(-1)?.[0]._hash);
   }
   currentBlockNumber() {
-    return assertEx50(this._chain.at(-1)?.[0].block);
+    return assertEx52(this._chain.at(-1)?.[0].block);
   }
   async payloadByHash(hash) {
     const payloads = await this.payloadsByHash([hash]);
@@ -7405,7 +7375,7 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 };
 
 // src/test/buildRandomChain.ts
-import { asAddress as asAddress2, assertEx as assertEx53 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx55 } from "@xylabs/sdk-js";
 import {
   Account as Account4,
   asSchema as asSchema9,
@@ -7424,7 +7394,7 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildBlock.ts
-import { assertEx as assertEx51, isDefined as isDefined21 } from "@xylabs/sdk-js";
+import { assertEx as assertEx53, isDefined as isDefined23 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload5,
   BoundWitnessBuilder as BoundWitnessBuilder3,
@@ -7507,8 +7477,8 @@ function buildStepHashes(blockNumber, inStepHashes, previousBlockHash, chainStep
         const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
         completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress2, { [completedStepRewardHolderAddress]: completedStepReward }));
       }
-      step_hashes.push(assertEx51(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
-    } else if (isDefined21(inStepHashes.at(i))) {
+      step_hashes.push(assertEx53(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+    } else if (isDefined23(inStepHashes.at(i))) {
       step_hashes.push(inStepHashes[i]);
     }
   }
@@ -7561,7 +7531,7 @@ async function buildBlock(options) {
     protocol
   }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder25.addStorageMeta(payloads));
   const [bw, txPayloads] = await builder.build();
-  assertEx51(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
+  assertEx53(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
   return [await PayloadBuilder25.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload5(p, true))];
 }
 
@@ -7582,7 +7552,7 @@ async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainS
 }
 
 // src/test/buildRandomGenesisBlock.ts
-import { asAddress, assertEx as assertEx52 } from "@xylabs/sdk-js";
+import { asAddress, assertEx as assertEx54 } from "@xylabs/sdk-js";
 import {
   Account as Account3,
   asAnyPayload as asAnyPayload6,
@@ -7626,7 +7596,7 @@ var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNu
 };
 
 // src/test/buildRandomGenesisBlock.ts
-var TestChainId = assertEx52(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
+var TestChainId = assertEx54(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
 
 // src/test/createGenesisBlock.ts
 import { PayloadBuilder as PayloadBuilder28 } from "@xyo-network/sdk-js";
@@ -7681,7 +7651,7 @@ var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genes
 };
 
 // src/test/buildRandomChain.ts
-var TestGenesisBlockRewardAddress = assertEx53(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
+var TestGenesisBlockRewardAddress = assertEx55(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
 var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId, transactionAccount, receiverAddresses) => {
   const chainIdToUse = chainId ?? TestChainId;
   const blocks = [];
@@ -7725,7 +7695,7 @@ var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId,
         receiverAddress
       ));
     }
-    const previousBlock2 = assertEx53(lastBlock?.[0], () => new Error("No last block"));
+    const previousBlock2 = assertEx55(lastBlock?.[0], () => new Error("No last block"));
     const block = await buildNextBlock(previousBlock2, txs, [], [blockProducer], transactionAccountToUse.address);
     blocks.push(block);
     remaining = remaining - 1;
@@ -7786,13 +7756,13 @@ function getTestProviderContext2(config) {
 }
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx54 } from "@xylabs/sdk-js";
+import { assertEx as assertEx56 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol-lib";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
   const hydratedBlock = await hydrateBlock(context, blockHash);
   const timePayload = asTimePayload3(hydratedBlock[1].find((p) => p.schema === TimeSchema2), { required: true });
-  return assertEx54(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx56(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 
 // src/validation/lib/isLocalhost.ts
@@ -7810,8 +7780,8 @@ var getUrl = (host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z as z31 } from "zod";
-var MnemonicStringZod = z31.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+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");
@@ -7856,23 +7826,20 @@ export {
   COIN_TYPES,
   ChainIndexingServiceStateSchema,
   ConfigZod,
-  TransportConfigZod as ConnectionConfigZod,
-  TransportsConfigZod as ConnectionsConfigZod,
+  ConnectionConfigZod,
+  ConnectionsConfigZod,
   CreatableProviderContextZod,
   DEFAULT_BACKOFF_MS,
   DEFAULT_MAX_ATTEMPTS,
   DEFAULT_MIN_CANDIDATES,
   DEFAULT_TOLERANCE_MS,
   DEFAULT_WALLET_PATH,
-  DataLakeConfigZod,
-  DataLakeDriverConfigBaseZod,
   DefaultMetricsScrapePorts,
   EIP712DataPayloadFieldsZod,
   EIP712DataPayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
-  EvmRpcTransportConfigZod as EvmConnectionConfigZod,
-  EvmRpcTransportConfigZod,
+  EvmRpcConnectionConfigZod,
   GlobalMetaSchema,
   HostActorConfigContext,
   HostActorConfigZod,
@@ -7880,17 +7847,15 @@ export {
   HydratedBoundWitnessWithStorageMetaZod,
   HydratedCache,
   JSONSchemaMetaSchema,
-  LmdbTransportConfigZod as LmdbConnectionConfigZod,
-  LmdbTransportConfigZod,
+  LmdbConnectionConfigZod,
   LoggerStatusReporter,
   MemoryArchivistFactory,
+  MemoryConnectionConfigZod,
   MemoryPermissionsStore,
-  MemoryTransportConfigZod,
   MissingCapabilityError,
   MnemonicStringZod,
   MongoConfigZod,
-  MongoTransportConfigZod as MongoConnectionConfigZod,
-  MongoTransportConfigZod,
+  MongoConnectionConfigZod,
   PENDING_BLOCKS_ARCHIVIST_ROLE,
   PENDING_TRANSACTIONS_ARCHIVIST_ROLE,
   PRODUCER_DIVERSITY_BONUS,
@@ -7905,23 +7870,18 @@ export {
   ProvidersConfigZod,
   REJECTED_BLOCKS_ARCHIVIST_ROLE,
   REJECTED_TRANSACTIONS_ARCHIVIST_ROLE,
-  RestTransportConfigZod as RestConnectionConfigZod,
-  RestDataLakeConfigZod,
+  RestConnectionConfigZod,
   RestDataLakeRunner,
   RestDataLakeViewer,
   RestSyncViewer,
-  RestTransportConfigZod,
   RewardMultipliers,
-  RouterDataLakeConfigZod,
-  RpcTransportConfigZod as RpcConnectionConfigZod,
+  RpcConnectionConfigZod,
   RpcRemoteConfigBaseZod,
   RpcRemoteConfigZod,
-  RpcTransportConfigZod,
   RuntimeStatusMonitor,
   RuntimeStatusMonitorZod,
   S3BucketConfigZod,
-  S3TransportConfigZod as S3ConnectionConfigZod,
-  S3TransportConfigZod,
+  S3ConnectionConfigZod,
   SchemasStepSummarySchema,
   ShiftedBigInt,
   SimpleAccountBalanceViewer,
@@ -7953,8 +7913,6 @@ export {
   TestGenesisBlockRewardAddress,
   TransactionBuilder,
   TransfersStepSummarySchema,
-  TransportConfigZod,
-  TransportsConfigZod,
   TypedDataDomainZod,
   TypedDataFieldZod,
   TypedDataTypesZod,
@@ -8124,6 +8082,7 @@ export {
   resolveConfig,
   resolveProviders,
   resolveProvidersFromConfig,
+  resolveRestConnectionEndpoint,
   rewardFromBlockNumber,
   schemasMaxStep,
   schemasStepSummaryFromRange,