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

package/dist/neutral/index.mjs

@@ -1120,9 +1120,6 @@ function factoryBackingsCompatible(declared, available) {
 }
 
 // src/config/normalizeConnectionsConfig.ts
-function mergeConnectionMaps(transports, connections) {
-  return { ...transports, ...connections };
-}
 function normalizeProviderBinding(binding) {
   const connectionName = binding.connection ?? binding.transport;
   if (connectionName === void 0 || connectionName === "") {
@@ -1143,18 +1140,14 @@ function normalizeProviderBindings(bindings) {
   return normalized;
 }
 function normalizeConnectionsConfig(config) {
-  const transports = config.transports ?? {};
-  const connections = config.connections ?? {};
-  const merged = mergeConnectionMaps(transports, connections);
   return {
     ...config,
-    connections: merged,
-    providerBindings: normalizeProviderBindings(config.providerBindings ?? {}),
-    transports: merged
+    connections: config.connections ?? {},
+    providerBindings: normalizeProviderBindings(config.providerBindings ?? {})
   };
 }
 function hasDeclaredConnectionProfiles(config) {
-  return Object.keys(config.transports ?? {}).length > 0 || Object.keys(config.connections ?? {}).length > 0;
+  return Object.keys(config.connections ?? {}).length > 0;
 }
 
 // src/CreatableProvider/ProviderFactoryLocator.ts
@@ -1714,10 +1707,10 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry14, z as z20 } from "zod/mini";
+import { globalRegistry as globalRegistry11, z as z17 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z19 } from "zod/mini";
+import { z as z16 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
@@ -1737,172 +1730,129 @@ var ChainConfigZod = z2.object({
 });
 
 // src/config/transports/Transport.ts
-import { globalRegistry as globalRegistry4, z as z6 } from "zod";
+import { globalRegistry as globalRegistry3, z as z5 } from "zod";
 
-// src/config/Remote.ts
+// src/config/transports/Mongo.ts
 import { globalRegistry as globalRegistry2, z as z3 } from "zod";
-var RpcRemoteConfigBaseZod = z3.object({
-  protocol: z3.string("http").register(globalRegistry2, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  })
-}).describe("Base configuration for the remote RPC");
-var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z3.string("http").register(globalRegistry2, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z3.string().register(globalRegistry2, {
-    description: "URL for the Chain RPC API",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using Http");
-var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z3.string().register(globalRegistry2, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z3.string().register(globalRegistry2, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z3.string().register(globalRegistry2, {
-    description: "Session ID to use for the postMessage RPC connection",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z3.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z3.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
-
-// src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined5, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry3, z as z4 } from "zod";
-var hasMongoConfig = (config) => {
-  if (isUndefined5(config)) return false;
-  return isDefined5(config.connectionString) && isDefined5(config.database) && isDefined5(config.domain);
-};
-var MongoConfigZod = z4.object({
+var MongoConfigZod = z3.object({
   // TODO: Create from other arguments
-  connectionString: z4.string().nonempty().optional().register(globalRegistry3, {
+  connectionString: z3.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z4.string().nonempty().optional().register(globalRegistry3, {
+  database: z3.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z4.string().nonempty().optional().register(globalRegistry3, {
+  domain: z3.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z4.string().nonempty().optional().register(globalRegistry3, {
+  password: z3.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z4.string().nonempty().optional().register(globalRegistry3, {
+  username: z3.string().nonempty().optional().register(globalRegistry2, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
   })
 });
 
-// src/config/storage/driver/S3.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
-import { z as z5 } from "zod";
-var S3BucketConfigZod = z5.object({
-  accessKeyId: z5.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
-  accountId: z5.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
-  bucket: z5.string().nonempty().optional().describe("S3-compatible bucket name"),
-  prefix: z5.string().nonempty().optional().describe("Optional key prefix within the bucket"),
-  readUrl: z5.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
-  secretAccessKey: z5.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
-});
-var S3ConfigZod = z5.object({
-  accessKeyId: z5.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
-  accountId: z5.string().nonempty().optional().describe("Shared account id (default for all buckets; on Cloudflare R2 it forms the endpoint)"),
-  chainState: S3BucketConfigZod.optional().describe("Bucket for the mutable chain state (the head pointer)"),
-  finalized: S3BucketConfigZod.optional().describe("Bucket for the finalized files (blocks, payloads, manifest)"),
-  index: S3BucketConfigZod.optional().describe("Bucket for the chain index (the step-summary families)"),
-  prefix: z5.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
-  secretAccessKey: z5.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
+// src/config/transports/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)"),
+  accountId: z4.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
+  bucket: z4.string().nonempty().optional().describe("S3-compatible bucket name"),
+  prefix: z4.string().nonempty().optional().describe("Optional key prefix within the bucket"),
+  readUrl: z4.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
+  secretAccessKey: z4.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
 });
-function resolveS3Bucket(config, which) {
-  if (config === void 0) return void 0;
-  const entry = config[which];
-  const accessKeyId = entry?.accessKeyId ?? config.accessKeyId;
-  const accountId = entry?.accountId ?? config.accountId;
-  const secretAccessKey = entry?.secretAccessKey ?? config.secretAccessKey;
-  const bucket = entry?.bucket ?? config.finalized?.bucket;
-  if (!isDefined6(accessKeyId) || !isDefined6(accountId) || !isDefined6(secretAccessKey) || !isDefined6(bucket)) return void 0;
-  return {
-    accessKeyId,
-    accountId,
-    bucket,
-    prefix: entry?.prefix ?? config.prefix,
-    readUrl: entry?.readUrl,
-    secretAccessKey
-  };
-}
-function hasS3Config(config, which = "finalized") {
-  return resolveS3Bucket(config, which) !== void 0;
-}
 
 // src/config/transports/Transport.ts
-var LmdbTransportConfigZod = z6.object({
-  access: z6.enum(["read", "write"]).optional().register(globalRegistry4, {
+var LmdbTransportConfigZod = z5.object({
+  access: z5.enum(["read", "write"]).optional().register(globalRegistry3, {
     description: "Access mode for this LMDB connection (read or write)",
     title: "transports.lmdb.access",
     type: "string"
   }),
-  root: z6.string().register(globalRegistry4, {
+  root: z5.string().register(globalRegistry3, {
     description: "Root directory for local LMDB storage",
     title: "transports.lmdb.root",
     type: "string"
   }),
-  store: z6.string().optional().register(globalRegistry4, {
+  store: z5.string().optional().register(globalRegistry3, {
     description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
     title: "transports.lmdb.store",
     type: "string"
   }),
-  type: z6.literal("lmdb")
+  type: z5.literal("lmdb")
 }).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z6.object({
-  type: z6.literal("mongo"),
+var MongoTransportConfigZod = 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 = HttpRpcRemoteConfigZod.extend({ type: z6.literal("rpc") }).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z6.object({
-  type: z6.literal("rest"),
-  baseUrl: z6.string().register(globalRegistry4, {
+var RpcTransportConfigZod = 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",
+    type: "string"
+  }),
+  url: z5.string().optional().register(globalRegistry3, {
+    description: "URL for the Chain RPC API (http protocol)",
+    title: "transports.rpc.url",
+    type: "string"
+  }),
+  networkId: z5.string().optional().register(globalRegistry3, {
+    description: "Network ID for the postMessage RPC connection",
+    title: "transports.rpc.networkId",
+    type: "string"
+  }),
+  sessionId: z5.string().optional().register(globalRegistry3, {
+    description: "Session ID for the postMessage RPC connection",
+    title: "transports.rpc.sessionId",
+    type: "string"
+  })
+}).describe("XL1 JSON-RPC transport");
+var RestTransportConfigZod = z5.object({
+  type: z5.literal("rest"),
+  baseUrl: z5.string().register(globalRegistry3, {
     description: "HTTP base URL for REST reads",
     title: "transports.rest.baseUrl",
     type: "string"
   })
 }).describe("HTTP REST read transport");
 var S3TransportConfigZod = S3BucketConfigZod.extend({
-  type: z6.literal("s3"),
-  accessKeyId: z6.string().optional(),
-  accountId: z6.string().optional(),
-  secretAccessKey: z6.string().optional()
+  type: z5.literal("s3"),
+  accessKeyId: z5.string().optional(),
+  accountId: z5.string().optional(),
+  secretAccessKey: z5.string().optional()
 }).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z6.object({
-  type: z6.literal("evm-rpc"),
-  url: z6.string().register(globalRegistry4, {
+var EvmRpcTransportConfigZod = z5.object({
+  type: z5.literal("evm-rpc"),
+  url: z5.string().register(globalRegistry3, {
     description: "EVM JSON-RPC URL",
     title: "transports.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",
+    type: "string"
   })
 }).describe("EVM JSON-RPC transport");
-var MemoryTransportConfigZod = z6.object({ type: z6.literal("memory") }).describe("In-process memory transport");
-var TransportConfigZod = z6.discriminatedUnion("type", [
+var MemoryTransportConfigZod = z5.object({ type: z5.literal("memory") }).describe("In-process memory transport");
+var TransportConfigZod = z5.discriminatedUnion("type", [
   LmdbTransportConfigZod,
   MongoTransportConfigZod,
   RpcTransportConfigZod,
@@ -1911,18 +1861,18 @@ var TransportConfigZod = z6.discriminatedUnion("type", [
   EvmRpcTransportConfigZod,
   MemoryTransportConfigZod
 ]);
-var TransportsConfigZod = z6.record(z6.string(), TransportConfigZod).default({});
+var TransportsConfigZod = z5.record(z5.string(), TransportConfigZod).default({});
 
 // src/config/DataLake/DataLake.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 
 // src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry6, z as z8 } from "zod";
+import { globalRegistry as globalRegistry5, z as z7 } from "zod";
 
 // src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry5, z as z7 } from "zod";
-var DataLakeDriverConfigBaseZod = z7.object({
-  driver: z7.string().register(globalRegistry5, {
+import { globalRegistry as globalRegistry4, z as z6 } from "zod";
+var DataLakeDriverConfigBaseZod = z6.object({
+  driver: z6.string().register(globalRegistry4, {
     description: "Driver for the data lake",
     type: "string"
   })
@@ -1930,76 +1880,45 @@ var DataLakeDriverConfigBaseZod = z7.object({
 
 // src/config/DataLake/RestDataLakeConfig.ts
 var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z8.literal("rest").register(globalRegistry6, {
+  driver: z7.literal("rest").register(globalRegistry5, {
     description: "Driver for the REST data lake",
     type: "string"
   }),
-  url: z8.string().register(globalRegistry6, {
+  url: z7.string().register(globalRegistry5, {
     description: "URL for the REST data lake",
     type: "string"
   })
 }).describe("Configuration for the REST data lake driver");
 
 // src/config/DataLake/RouterDataLakeConfig.ts
-import { globalRegistry as globalRegistry7, z as z9 } from "zod";
-var RouterDataLakeConfigZod = z9.object({
-  driver: z9.literal("router").register(globalRegistry7, {
+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",
     type: "string"
   }),
-  children: z9.array(z9.lazy(() => DataLakeConfigZod)).register(globalRegistry7, {
+  children: z8.array(z8.lazy(() => DataLakeConfigZod)).register(globalRegistry6, {
     description: "Child data lake drivers",
     type: "array"
   })
 }).describe("Configuration for the router data lake driver");
 
 // src/config/DataLake/DataLake.ts
-var DataLakeConfigZod = z10.lazy(() => z10.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
-
-// src/config/Evm.ts
-import { globalRegistry as globalRegistry8, z as z11 } from "zod";
-var EvmInfuraConfigZod = z11.object({
-  projectId: z11.string().optional().register(globalRegistry8, {
-    description: "Infura project ID",
-    title: "evm.infura.projectId",
-    type: "string"
-  }),
-  projectSecret: z11.string().optional().register(globalRegistry8, {
-    description: "Infura project secret",
-    title: "evm.infura.projectSecret",
-    type: "string"
-  })
-});
-var EvmJsonRpcConfigZod = z11.object({
-  url: z11.url().optional().register(globalRegistry8, {
-    description: "JSON-RPC URL",
-    title: "evm.jsonRpc.url",
-    type: "string"
-  })
-});
-var EvmConfigZod = z11.object({
-  chainId: z11.string().optional().register(globalRegistry8, {
-    description: "EVM chain ID",
-    title: "evm.chainId",
-    type: "string"
-  }),
-  infura: EvmInfuraConfigZod.optional().describe("Infura Provider configuration"),
-  jsonRpc: EvmJsonRpcConfigZod.optional().describe("JSON-RPC Provider configuration")
-});
+var DataLakeConfigZod = z9.lazy(() => z9.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry9, z as z12 } from "zod";
+import { globalRegistry as globalRegistry7, z as z10 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z12.object({
-  logLevel: z12.enum(LogLevelNames).default("info").register(globalRegistry9, {
+var LogConfigZod = z10.object({
+  logLevel: z10.enum(LogLevelNames).default("info").register(globalRegistry7, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z12.boolean().default(false).register(globalRegistry9, {
+  silent: z10.boolean().default(false).register(globalRegistry7, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -2008,23 +1927,23 @@ var LogConfigZod = z12.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry10, z as z13 } from "zod";
-var ProviderBindingConfigZod = z13.object({
-  connection: z13.string().optional().register(globalRegistry10, {
+import { globalRegistry as globalRegistry8, z as z11 } from "zod";
+var ProviderBindingConfigZod = z11.object({
+  connection: z11.string().optional().register(globalRegistry8, {
     description: "Named connection from the top-level connections map",
     title: "providerBindings.connection",
     type: "string"
   }),
-  transport: z13.string().optional().register(globalRegistry10, {
+  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 = z13.record(z13.string(), ProviderBindingConfigZod).default({});
+var ProviderBindingsConfigZod = z11.record(z11.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z15 from "zod";
+import z13 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -2032,32 +1951,20 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z14 } from "zod";
-var ProviderConfigZod = z14.object({
-  moniker: z14.string(),
-  labels: z14.array(z14.string()).optional()
+import { z as z12 } from "zod";
+var ProviderConfigZod = z12.object({
+  moniker: z12.string(),
+  labels: z12.array(z12.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 = z15.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
-
-// src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry11, z as z16 } from "zod";
-var StorageConfigZod = z16.object({
-  mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z16.string().optional().register(globalRegistry11, {
-    description: "Root directory for local storage",
-    title: "storage.root",
-    type: "string"
-  }),
-  s3: S3ConfigZod.optional().describe("Configuration for S3-compatible object storage (e.g. Cloudflare R2)")
-}).describe("Storage configuration options");
+var ProvidersConfigZod = z13.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry12, z as z17 } from "zod";
+import { globalRegistry as globalRegistry9, z as z14 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -2065,29 +1972,29 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z17.object({
-  path: z17.string().default("/metrics").register(globalRegistry12, {
+var MetricsScrapeConfigZod = z14.object({
+  path: z14.string().default("/metrics").register(globalRegistry9, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z17.coerce.number().int().positive().optional().register(globalRegistry12, {
-    description: "Port for the metrics scrape endpoint",
+  port: z14.coerce.number().int().nonnegative().optional().register(globalRegistry9, {
+    description: "Port for the metrics scrape endpoint (0 disables the scrape endpoint)",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z17.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z17.object({
+var MetricsConfigZod = z14.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z14.object({
   // OpenTelemetry options
-  otlpEndpoint: z17.url().optional().register(globalRegistry12, {
+  otlpEndpoint: z14.url().optional().register(globalRegistry9, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z17.object({
+var TelemetryConfigZod = z14.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -2096,7 +2003,7 @@ var TelemetryConfigZod = z17.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
-import { globalRegistry as globalRegistry13, z as z18 } from "zod";
+import { globalRegistry as globalRegistry10, z as z15 } from "zod";
 
 // src/primitives/block/range/blockRangeSteps.ts
 import { asXL1BlockNumber as asXL1BlockNumber2, StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
@@ -2117,11 +2024,11 @@ function blockRangeSteps(range, steps) {
 }
 
 // src/primitives/block/rate/blockRate.ts
-import { isDefined as isDefined8, isFalsy } from "@xylabs/sdk-js";
+import { isDefined as isDefined6, isFalsy } from "@xylabs/sdk-js";
 import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
 
 // src/primitives/block/rate/timeHelpers.ts
-import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, isDefined as isDefined5 } from "@xylabs/sdk-js";
 var rateMultipliers = {
   millis: 1,
   seconds: 1e3,
@@ -2139,7 +2046,7 @@ var timeDurations = (timeInMs) => ({
   weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
 });
 var getTimeConfigInMilliseconds = (timeConfig) => {
-  const assertedTimeConfig = assertEx10(isDefined7(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
+  const assertedTimeConfig = assertEx10(isDefined5(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
   let totalMilliseconds = 0;
   if ("years" in assertedTimeConfig) {
     totalMilliseconds += assertedTimeConfig.years * 31536e6;
@@ -2178,13 +2085,13 @@ var blockRate = (startBlock, endBlock, timeUnit) => {
     throw new Error("Time difference must be greater than 0");
   }
   const rate = heightDifference / timeDifference;
-  const timeUnitValue = isDefined8(timeUnit) ? timeUnit : "millis";
-  const returnedTimeDifference = isDefined8(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timeUnitValue = isDefined6(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined6(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
   const timePerBlock = returnedTimeDifference / heightDifference;
   return {
     range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
     span: heightDifference,
-    rate: isDefined8(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    rate: isDefined6(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
     timeUnit: timeUnitValue,
     timeDifference: returnedTimeDifference,
     timePerBlock
@@ -2232,7 +2139,7 @@ var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit
 // src/primitives/block/rate/timeRate.ts
 import {
   assertEx as assertEx12,
-  isDefined as isDefined9,
+  isDefined as isDefined7,
   isDefinedNotNull
 } from "@xylabs/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber3, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
@@ -2271,7 +2178,7 @@ var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBl
   }
   const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
   const resolvedEndBlock = assertEx12(
-    isDefined9(endBlock?.[0]) ? endBlock[0] : void 0,
+    isDefined7(endBlock?.[0]) ? endBlock[0] : void 0,
     () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
   );
   const endBlockEpoch = resolvedEndBlock.$epoch;
@@ -2308,7 +2215,7 @@ var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBl
 // src/primitives/chain/getWindowedChain.ts
 import {
   assertEx as assertEx13,
-  isDefined as isDefined10,
+  isDefined as isDefined8,
   isNull,
   spanRootAsync
 } from "@xylabs/sdk-js";
@@ -2322,7 +2229,7 @@ async function getWindowedChain(context, blockViewer, maxWindowSize, previousCha
     while (currentBlock !== null && newChain.length < maxWindowSize) {
       const currentBlockNumber = currentBlock[0].block;
       const nextBlock = newChain[0];
-      if (isDefined10(nextBlock)) {
+      if (isDefined8(nextBlock)) {
         const nextBlockNumber = nextBlock[0].block;
         assertEx13(
           currentBlockNumber === nextBlockNumber - 1,
@@ -2419,7 +2326,7 @@ async function chainStepRewardAddress(context, blockViewer, { block, step }) {
 }
 
 // src/primitives/chain/step/stepRewardTotal.ts
-import { assertEx as assertEx17, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17, isDefined as isDefined9 } from "@xylabs/sdk-js";
 import {
   asAttoXL1,
   asXL1BlockRange as asXL1BlockRange5,
@@ -2512,7 +2419,7 @@ function stepInRange(step, range) {
   return stepRange[0] >= range[0] && stepRange[1] <= range[1];
 }
 async function stepRewardTotal(context, blockViewer, { block, step }, multipliers) {
-  const cacheKey = `${block}|${step}|${isDefined11(multipliers)}`;
+  const cacheKey = `${block}|${step}|${isDefined9(multipliers)}`;
   return await withContextCacheResponse(context, "stepRewardTotal", cacheKey, async () => {
     const [blockBw, payloads] = await stepRewardBlock(context, blockViewer, { block, step });
     assertEx17(blockBw.block === block, () => `Block Mismatch: expected ${block}, got ${blockBw.block}`);
@@ -2603,7 +2510,7 @@ async function externalBlockRangeFromStep(context, blockViewer, stepIdentity) {
 }
 
 // src/primitives/mapToMapType.ts
-import { isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { isDefined as isDefined10 } from "@xylabs/sdk-js";
 function mapToMapType(map) {
   return {
     get: (key) => map.get(key),
@@ -2622,7 +2529,7 @@ function mapToMapType(map) {
       const result = [];
       for (const key of keys) {
         const value = map.get(key);
-        if (isDefined12(value)) {
+        if (isDefined10(value)) {
           result.push(value);
         }
       }
@@ -2637,7 +2544,7 @@ function mapToMapType(map) {
 }
 
 // src/primitives/readPayloadMapFromStore.ts
-import { isDefined as isDefined13 } from "@xylabs/sdk-js";
+import { isDefined as isDefined11 } from "@xylabs/sdk-js";
 function readPayloadMapFromStore(store) {
   if (isReadArchivist(store)) {
     return {
@@ -2650,7 +2557,7 @@ function readPayloadMapFromStore(store) {
       },
       has: async (hash) => {
         const results = await store.get([hash]);
-        return isDefined13(results[0]);
+        return isDefined11(results[0]);
       }
     };
   }
@@ -2668,7 +2575,7 @@ function payloadMapFromStore(store) {
       },
       has: async (hash) => {
         const results = await store.get([hash]);
-        return isDefined13(results[0]);
+        return isDefined11(results[0]);
       },
       clear: async () => {
         return await store.clear();
@@ -2714,7 +2621,7 @@ function rewardFromBlockNumber(blockNumber) {
 import { XYO_NETWORK_STAKING_ADDRESS } from "@xyo-network/xl1-protocol-lib";
 
 // src/primitives/stake/activeStakeAtTimeByAddress.ts
-import { isDefined as isDefined14 } from "@xylabs/sdk-js";
+import { isDefined as isDefined12 } from "@xylabs/sdk-js";
 
 // src/primitives/stake/mergedAddRemoveStakeEventsByStaker.ts
 async function mergedAddRemoveStakeEventsByStaker(chainEvents, range, staked, staker) {
@@ -2734,7 +2641,7 @@ async function activeStakeAtTimeByAddress(chain, staked, time, staker) {
   for (const event of stakeEvents) {
     if (event.time > time) break;
     if (event.args.staked !== staked) continue;
-    if (isDefined14(staker) && event.args.staker !== staker) continue;
+    if (isDefined12(staker) && event.args.staker !== staker) continue;
     if (event.name === "StakeAdded") {
       result += event.args.amount;
     } else if (event.name === "StakeRemoved") {
@@ -2745,7 +2652,7 @@ async function activeStakeAtTimeByAddress(chain, staked, time, staker) {
 }
 
 // src/primitives/stake/activeStakeAtTimeByPosition.ts
-import { isUndefined as isUndefined6 } from "@xylabs/sdk-js";
+import { isUndefined as isUndefined5 } from "@xylabs/sdk-js";
 
 // src/primitives/stake/mergedAddRemoveStakeEventsByPosition.ts
 async function mergedAddRemoveStakeEventsByPosition(chainEvents, range, position) {
@@ -2764,7 +2671,7 @@ async function activeStakeAtTimeByPosition(chainStakeEvents, externalTime, posit
   let result = 0n;
   for (const event of stakeEvents) {
     if (event.time > externalTime) break;
-    if (isUndefined6(position) || position === Number(event.args.id)) {
+    if (isUndefined5(position) || position === Number(event.args.id)) {
       if (event.name === "StakeAdded") {
         result += event.args.amount;
       } else if (event.name === "StakeRemoved") {
@@ -2808,20 +2715,20 @@ async function allStakersForStep(context, blockViewer, stakeEventsViewer, stepCo
 }
 
 // src/primitives/stake/weightedStakeForRangeByPosition.ts
-import { isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { isDefined as isDefined13 } from "@xylabs/sdk-js";
 import { asBlockNumber as asBlockNumber2 } from "@xyo-network/xl1-protocol-lib";
 async function weightedStakeForRangeByPosition(context, blockViewer, stakeEventsViewer, externalRange, staked, positionId) {
-  const cacheKey = isDefined15(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`;
+  const cacheKey = isDefined13(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`;
   return await withContextCacheResponse(context, "weightedStakeForRangeByPosition", cacheKey, async () => {
     let weightedStakeSum = 0n;
-    if (isDefined15(positionId)) {
+    if (isDefined13(positionId)) {
       const mergedEventsResult = await mergedAddRemoveStakeEventsByPosition(
         stakeEventsViewer,
         [0, externalRange[1]],
         positionId
       );
       const mergedEvents = mergedEventsResult.toSorted((a, b) => a.time - b.time);
-      if (isDefined15(staked) && mergedEvents.at(0)?.args.staked !== staked) {
+      if (isDefined13(staked) && mergedEvents.at(0)?.args.staked !== staked) {
         return 0n;
       }
       let currentTime = externalRange[0];
@@ -3014,24 +2921,24 @@ function findUncles(context, finalizedWindowedChain, blocks) {
 }
 
 // src/config/Validation.ts
-var ValidationConfigZod = z18.object({
-  allowedRewardRedeemers: z18.array(XyoAddressZod2).optional().register(globalRegistry13, {
+var ValidationConfigZod = z15.object({
+  allowedRewardRedeemers: z15.array(XyoAddressZod2).optional().register(globalRegistry10, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z18.array(XyoAddressZod2).optional().register(globalRegistry13, {
+  allowedRewardEscrowAccountSigners: z15.array(XyoAddressZod2).optional().register(globalRegistry10, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z18.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry13, {
+  minCandidates: z15.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry10, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z18.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry13, {
+  backoffMs: z15.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry10, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -3040,29 +2947,25 @@ var ValidationConfigZod = z18.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z19.object({
-  chain: z19._default(ChainConfigZod, ChainConfigZod.parse({})).check(z19.describe("Configuration for the chain")),
-  dataLake: z19.optional(DataLakeConfigZod).check(z19.describe("Configuration for data lakes")),
-  evm: z19._default(EvmConfigZod, EvmConfigZod.parse({})).check(z19.describe("Configuration for EVM-backed services")),
-  log: z19._default(LogConfigZod, LogConfigZod.parse({})).check(z19.describe("Configuration for logging")),
-  connections: z19._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z19.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
-  providerBindings: z19._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z19.describe("Per-moniker provider connection bindings")),
-  providers: z19._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z19.describe("Configuration for providers")),
-  remote: z19._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z19.describe("Configuration for remote services")),
-  transports: z19._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z19.describe("Deprecated alias for connections (kept in sync during migration)")),
-  storage: z19._default(StorageConfigZod, StorageConfigZod.parse({})).check(z19.describe("Configuration for the storage")),
-  telemetry: z19._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z19.describe("Configuration for telemetry")),
-  validation: z19._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z19.describe("Configuration for validation"))
+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"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z20.string().check(z20.regex(
+var AccountPathZod = z17.string().check(z17.regex(
   /^(m(\/\d+'?)+|\d+'?(\/\d+'?)*)$/,
   `Invalid BIP-32 derivation path. Use either an absolute path like "m/44'/60'/0'/0/0" or a relative path like "0", "0/1", or "44'/60'/0'/0/0".`
 ));
-var ActorConfigZod = z20.extend(BaseConfigZod, {
-  name: z20.string(),
-  accountPath: z20.optional(AccountPathZod).register(globalRegistry14, {
+var ActorConfigZod = z17.extend(BaseConfigZod, {
+  name: z17.string(),
+  accountPath: z17.optional(AccountPathZod).register(globalRegistry11, {
     description: 'BIP-32 derivation path for the actor wallet. Absolute when it starts with "m/"; otherwise relative to the root wallet base path. Each actor must derive to a distinct path.',
     title: "accountPath",
     type: "string"
@@ -3073,25 +2976,22 @@ var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z21 } from "zod/mini";
-var ActorsConfigZod = z21._default(
-  z21.array(z21.looseObject(ActorConfigZod.shape)).check(z21.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+import { z as z18 } from "zod/mini";
+var ActorsConfigZod = z18._default(
+  z18.array(z18.looseObject(ActorConfigZod.shape)).check(z18.describe("Actor-specific configurations that override the base configuration when the actor is running")),
   []
 );
 
-// src/config/adaptLegacyConfig.ts
-import { isDefined as isDefined16 } from "@xylabs/sdk-js";
-
 // src/config/Config.ts
-import { globalRegistry as globalRegistry15, z as z22 } from "zod/mini";
-var ConfigZod = z22.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry12, z as z19 } from "zod/mini";
+var ConfigZod = z19.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z22.optional(z22.coerce.number()).register(globalRegistry15, {
+  healthCheckPort: z19.optional(z19.coerce.number()).register(globalRegistry12, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).check(z22.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z19.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 function resolveConfig(config) {
   const parsedConfig = ConfigZod.parse(config);
   const {
@@ -3100,108 +3000,38 @@ function resolveConfig(config) {
     ...rootConfig
   } = parsedConfig;
   parsedConfig.actors = actors.map((actorConfig) => {
-    return z22.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
+    return z19.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
   });
   return parsedConfig;
 }
 
-// src/config/adaptLegacyConfig.ts
-var DEFAULT_LMDB_TRANSPORT = "local-store";
-var DEFAULT_RPC_TRANSPORT = "default-rpc";
-var DEFAULT_EVM_RPC_TRANSPORT = "default-evm-rpc";
-var S3_FINALIZED_TRANSPORT = "s3-finalized";
-var S3_CHAIN_STATE_TRANSPORT = "s3-chain-state";
-var S3_INDEX_TRANSPORT = "s3-index";
-function rpcTransportFromRemote(rpc) {
-  if (rpc.protocol === "http" && "url" in rpc) {
-    const http = rpc;
-    return {
-      type: "rpc",
-      protocol: "http",
-      url: http.url
-    };
-  }
-  return {
-    type: "rpc",
-    protocol: rpc.protocol,
-    url: "url" in rpc ? String(rpc.url) : ""
-  };
-}
-function s3TransportFromBucket(shared, entry, fallbackBucket) {
-  if (!isDefined16(entry?.bucket) && !isDefined16(entry?.readUrl)) {
-    return void 0;
-  }
-  return {
-    type: "s3",
-    accessKeyId: entry?.accessKeyId ?? shared.accessKeyId,
-    accountId: entry?.accountId ?? shared.accountId,
-    bucket: entry?.bucket ?? fallbackBucket,
-    prefix: entry?.prefix ?? shared.prefix,
-    readUrl: entry?.readUrl,
-    secretAccessKey: entry?.secretAccessKey ?? shared.secretAccessKey
-  };
-}
-function synthesizeS3Transports(s3) {
-  const shared = {
-    accessKeyId: s3.accessKeyId,
-    accountId: s3.accountId,
-    prefix: s3.prefix,
-    secretAccessKey: s3.secretAccessKey
-  };
-  const transports = {};
-  const finalized = s3TransportFromBucket(shared, s3.finalized);
-  const fallbackBucket = s3.finalized?.bucket;
-  if (finalized) {
-    transports[S3_FINALIZED_TRANSPORT] = finalized;
-  }
-  const chainState = s3TransportFromBucket(shared, s3.chainState, fallbackBucket);
-  if (chainState) {
-    transports[S3_CHAIN_STATE_TRANSPORT] = chainState;
-  }
-  const index = s3TransportFromBucket(shared, s3.index, fallbackBucket);
-  if (index) {
-    transports[S3_INDEX_TRANSPORT] = index;
-  }
-  return transports;
-}
-function hasTransport(transports, key) {
-  return Object.hasOwn(transports, key) && transports[key] !== void 0;
-}
-function bindMoniker2(bindings, moniker, connectionName) {
-  bindings[moniker] = { connection: connectionName, transport: connectionName };
-}
-var LMDB_MONIKERS = [
-  "AccountBalanceViewer",
-  "BlockRewardViewer",
-  "BlockRunner",
-  "BlockValidationViewer",
-  "BlockViewer",
-  "ChainContractViewer",
-  "DeadLetterQueueRunner",
-  "DeadLetterQueueViewer",
-  "FinalizationRunner",
-  "FinalizationViewer",
-  "MempoolRunner",
-  "MempoolViewer",
-  "NetworkStakeViewer",
-  "NetworkStakeStepRewardsByPositionViewer",
-  "NetworkStakeStepRewardsByStakerViewer",
-  "NetworkStakeStepRewardsByStepViewer",
-  "NetworkStakeStepRewardsTotalViewer",
-  "NetworkStakeStepRewardsViewer",
-  "StakeEventsViewer",
-  "StakeTotalsViewer",
-  "StakeViewer",
-  "StepViewer",
-  "TimeSyncViewer",
-  "TransactionValidationViewer",
-  "TransactionViewer",
-  "WindowedBlockViewer",
-  "XyoConnection",
-  "XyoGateway",
-  "XyoRunner",
-  "XyoViewer"
-];
+// src/config/HostActor.ts
+import {
+  zodAsFactory as zodAsFactory4,
+  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, {
+    default: "localhost",
+    description: "Host for the Actor",
+    title: "host",
+    type: "string"
+  }),
+  port: z20._default(z20.coerce.number(), 8080).register(globalRegistry13, {
+    default: 8080,
+    description: "Port for the Actor",
+    title: "port",
+    type: "number"
+  })
+});
+var isHostActorConfig = zodIsFactory3(HostActorConfigZod);
+var asHostActorConfig = zodAsFactory4(HostActorConfigZod, "asHostActorConfig");
+var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
+
+// src/config/synthesizeRpcConnectionBindings.ts
+var DEFAULT_RPC_CONNECTION = "default-rpc";
 var RPC_MONIKERS = [
   "AccountBalanceViewer",
   "BlockRewardViewer",
@@ -3223,133 +3053,73 @@ var RPC_MONIKERS = [
   "WindowedBlockViewer",
   "XyoViewer"
 ];
-function synthesizeLmdbProviderBindings(transports) {
+function synthesizeRpcConnectionBindings() {
   const bindings = {};
-  if (!hasTransport(transports, DEFAULT_LMDB_TRANSPORT)) {
-    return bindings;
-  }
-  for (const moniker of LMDB_MONIKERS) {
-    bindMoniker2(bindings, moniker, DEFAULT_LMDB_TRANSPORT);
-  }
-  return bindings;
-}
-function synthesizeProviderBindings(transports) {
-  const bindings = {};
-  if (hasTransport(transports, DEFAULT_RPC_TRANSPORT)) {
-    for (const moniker of RPC_MONIKERS) {
-      bindMoniker2(bindings, moniker, DEFAULT_RPC_TRANSPORT);
-    }
-  }
-  if (hasTransport(transports, S3_FINALIZED_TRANSPORT)) {
-    bindMoniker2(bindings, "BlockPublishRunner", S3_FINALIZED_TRANSPORT);
-  }
-  if (hasTransport(transports, S3_CHAIN_STATE_TRANSPORT)) {
-    bindMoniker2(bindings, "ChainStateViewer", S3_CHAIN_STATE_TRANSPORT);
-    bindMoniker2(bindings, "ChainStatePublishRunner", S3_CHAIN_STATE_TRANSPORT);
-  }
-  if (hasTransport(transports, S3_INDEX_TRANSPORT)) {
-    bindMoniker2(bindings, "IndexPublishRunner", S3_INDEX_TRANSPORT);
-  }
-  if (hasTransport(transports, DEFAULT_EVM_RPC_TRANSPORT)) {
-    bindMoniker2(bindings, "ChainContractViewer", DEFAULT_EVM_RPC_TRANSPORT);
-    bindMoniker2(bindings, "StakeEventsViewer", DEFAULT_EVM_RPC_TRANSPORT);
-    bindMoniker2(bindings, "StakeTotalsViewer", DEFAULT_EVM_RPC_TRANSPORT);
-    bindMoniker2(bindings, "StakeViewer", DEFAULT_EVM_RPC_TRANSPORT);
-    bindMoniker2(bindings, "TimeSyncViewer", DEFAULT_EVM_RPC_TRANSPORT);
+  for (const moniker of RPC_MONIKERS) {
+    bindings[moniker] = { connection: DEFAULT_RPC_CONNECTION, transport: DEFAULT_RPC_CONNECTION };
   }
   return bindings;
 }
-function adaptLegacyConfig(config) {
-  const parsed = ConfigZod.parse(config);
-  if (hasDeclaredConnectionProfiles(parsed)) {
-    return ConfigZod.parse(normalizeConnectionsConfig(parsed));
-  }
-  const transports = { ...parsed.transports, ...parsed.connections };
-  if (isDefined16(parsed.storage?.root) && parsed.storage.root !== "") {
-    transports[DEFAULT_LMDB_TRANSPORT] = { type: "lmdb", root: parsed.storage.root };
-  }
-  if (hasMongoConfig(parsed.storage?.mongo)) {
-    transports["chain-mongo"] = {
-      type: "mongo",
-      connectionString: parsed.storage.mongo.connectionString,
-      database: parsed.storage.mongo.database,
-      domain: parsed.storage.mongo.domain,
-      password: parsed.storage.mongo.password,
-      username: parsed.storage.mongo.username
-    };
-  }
-  if (isDefined16(parsed.remote?.rpc)) {
-    transports[DEFAULT_RPC_TRANSPORT] = rpcTransportFromRemote(parsed.remote.rpc);
-  }
-  if (isDefined16(parsed.evm?.jsonRpc?.url)) {
-    transports[DEFAULT_EVM_RPC_TRANSPORT] = { type: "evm-rpc", url: parsed.evm.jsonRpc.url };
-  }
-  if (isDefined16(parsed.storage?.s3)) {
-    Object.assign(transports, synthesizeS3Transports(parsed.storage.s3));
-  }
-  const providerBindings = {
-    ...synthesizeLmdbProviderBindings(transports),
-    ...synthesizeProviderBindings(transports),
-    ...parsed.providerBindings
-  };
-  return ConfigZod.parse(normalizeConnectionsConfig({
-    ...parsed,
-    connections: transports,
-    providerBindings,
-    transports
-  }));
-}
 
-// src/config/HostActor.ts
-import {
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory3
-} from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry16, z as z23 } from "zod/mini";
-var HostActorConfigZod = z23.extend(ActorConfigZod, {
-  host: z23._default(z23.string(), "localhost").register(globalRegistry16, {
-    default: "localhost",
-    description: "Host for the Actor",
-    title: "host",
+// 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"
   }),
-  port: z23._default(z23.coerce.number(), 8080).register(globalRegistry16, {
-    default: 8080,
-    description: "Port for the Actor",
-    title: "port",
-    type: "number"
+  sessionId: z21.string().register(globalRegistry14, {
+    description: "Session ID to use for the postMessage RPC connection",
+    type: "string"
   })
-});
-var isHostActorConfig = zodIsFactory3(HostActorConfigZod);
-var asHostActorConfig = zodAsFactory4(HostActorConfigZod, "asHostActorConfig");
-var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
+}).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 z24 } from "zod";
-var DescriptionSchema = z24.string();
-var TitleSchema = z24.string();
-var JSONSchemaMetaSchema = z24.object({
-  id: z24.string().optional(),
+import { z as z22 } from "zod";
+var DescriptionSchema = z22.string();
+var TitleSchema = z22.string();
+var JSONSchemaMetaSchema = z22.object({
+  id: z22.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z24.boolean().optional()
-}).catchall(z24.unknown());
+  deprecated: z22.boolean().optional()
+}).catchall(z22.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z24.array(z24.union([z24.string(), z24.number(), z24.literal(true), z24.undefined()])).readonly();
+var ChoicesSchema = z22.array(z22.union([z22.string(), z22.number(), z22.literal(true), z22.undefined()])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z24.unknown().optional(),
+  default: z22.unknown().optional(),
   description: DescriptionSchema,
-  group: z24.string().optional(),
-  hidden: z24.boolean().optional(),
+  group: z22.string().optional(),
+  hidden: z22.boolean().optional(),
   title: TitleSchema,
-  type: z24.union([
-    z24.literal("array"),
-    z24.literal("count"),
-    z24.literal("boolean"),
-    z24.literal("number"),
-    z24.literal("string")
+  type: z22.union([
+    z22.literal("array"),
+    z22.literal("count"),
+    z22.literal("boolean"),
+    z22.literal("number"),
+    z22.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -3362,7 +3132,7 @@ import {
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
-import { z as z26 } from "zod/mini";
+import { z as z24 } from "zod/mini";
 
 // src/model/CreatableProviderContext.zod.ts
 import {
@@ -3371,17 +3141,17 @@ import {
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z25 } from "zod/mini";
-var RuntimeStatusMonitorZod = z25.custom((val) => val !== null && val !== void 0 && typeof val === "object");
-var ProviderFactoryLocatorZod = z25.lazy(() => z25.custom((val) => val !== null && val !== void 0 && typeof val === "object" && "context" in val && "registry" in val));
-var BaseConfigContextZod = z25.extend(CachingContextZod, {
-  config: z25.looseObject(BaseConfigZod.shape),
-  locator: z25.optional(ProviderFactoryLocatorZod)
+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)
 });
-var CreatableProviderContextZod = z25.lazy(() => z25.extend(BaseConfigContextZod, {
-  _id: z25.optional(z25.string()),
+var CreatableProviderContextZod = z23.lazy(() => z23.extend(BaseConfigContextZod, {
+  _id: z23.optional(z23.string()),
   locator: ProviderFactoryLocatorZod,
-  statusReporter: z25.optional(RuntimeStatusMonitorZod)
+  statusReporter: z23.optional(RuntimeStatusMonitorZod)
 }));
 var isBaseConfigContext = zodIsFactory4(BaseConfigContextZod);
 var asBaseConfigContext = zodAsFactory5(BaseConfigContextZod, "asBaseConfigContext");
@@ -3502,7 +3272,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 // src/transaction/confirmSubmittedTransaction.ts
 import {
   delay,
-  isDefined as isDefined17,
+  isDefined as isDefined14,
   isNumber
 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
@@ -3524,7 +3294,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
   let attempts = 0;
   while (true) {
     const tx = await viewer.transaction.byHash(txHash) ?? void 0;
-    if (isDefined17(tx)) {
+    if (isDefined14(tx)) {
       options?.logger?.debug("Transaction confirmed", txHash);
       return tx;
     }
@@ -3835,11 +3605,23 @@ var bundle2 = (root, transaction) => {
 };
 
 // src/context/Actor.ts
-var ActorConfigContext = z26.extend(BaseConfigContextZod, { config: ActorConfigZod });
+var ActorConfigContext = z24.extend(BaseConfigContextZod, { config: ActorConfigZod });
 var isActorConfigContext = zodIsFactory5(ActorConfigContext);
 var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
 var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
 
+// src/context/HostActor.ts
+import {
+  zodAsFactory as zodAsFactory7,
+  zodIsFactory as zodIsFactory6,
+  zodToFactory as zodToFactory6
+} from "@xylabs/sdk-js";
+import { z as z25 } from "zod/mini";
+var HostActorConfigContext = z25.extend(BaseConfigContextZod, { config: HostActorConfigZod });
+var isHostActorConfigContext = zodIsFactory6(HostActorConfigContext);
+var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActorConfigContext");
+var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
+
 // src/CreatableProvider/AbstractCreatableProvider.ts
 import {
   AbstractCreatable,
@@ -3921,42 +3703,14 @@ function labeledCreatableProvider() {
   };
 }
 
-// src/context/getEmptyProviderContext.ts
-function getEmptyProviderContext(config) {
-  const singletons = {};
-  const caches = {};
-  const locator = new ProviderFactoryLocator({
-    config,
-    singletons,
-    caches,
-    logger: console
-  });
-  return locator.context;
-}
-function getEmptyContext(config) {
-  return getEmptyProviderContext(config);
-}
-
-// src/context/HostActor.ts
-import {
-  zodAsFactory as zodAsFactory7,
-  zodIsFactory as zodIsFactory6,
-  zodToFactory as zodToFactory6
-} from "@xylabs/sdk-js";
-import { z as z27 } from "zod/mini";
-var HostActorConfigContext = z27.extend(BaseConfigContextZod, { config: HostActorConfigZod });
-var isHostActorConfigContext = zodIsFactory6(HostActorConfigContext);
-var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActorConfigContext");
-var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
-
 // src/createDeclarationPayload.ts
-import { isDefined as isDefined18 } from "@xylabs/sdk-js";
+import { isDefined as isDefined15 } 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 = isDefined18(exp) ? exp : nbf + 1e4;
+  const expiration = isDefined15(exp) ? exp : nbf + 1e4;
   const payloadBuilder = new PayloadBuilder13({ schema: ChainStakeIntentSchema });
   const builder = payloadBuilder.fields({
     from: address,
@@ -3988,26 +3742,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z29 } from "zod";
+import { z as z27 } from "zod";
 
 // src/eip-712/Types.ts
-import { z as z28 } from "zod";
-var TypedDataDomainZod = z28.object({
-  name: z28.string().nullable().optional(),
-  version: z28.string().nullable().optional(),
-  chainId: z28.union([z28.string(), z28.number(), z28.bigint()]).nullable().optional(),
-  verifyingContract: z28.string().nullable().optional(),
-  salt: z28.union([z28.string(), z28.instanceof(Uint8Array)]).nullable().optional()
+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()
 });
-var TypedDataFieldZod = z28.object({
-  name: z28.string(),
-  type: z28.string()
+var TypedDataFieldZod = z26.object({
+  name: z26.string(),
+  type: z26.string()
 });
-var TypedDataTypesZod = z28.record(z28.string(), z28.array(TypedDataFieldZod));
-var TypedDataValueZod = z28.record(z28.string(), z28.any());
+var TypedDataTypesZod = z26.record(z26.string(), z26.array(TypedDataFieldZod));
+var TypedDataValueZod = z26.record(z26.string(), z26.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z29.object({
+var EIP712DataPayloadFieldsZod = z27.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -4025,11 +3779,11 @@ import {
   asSchema as asSchema3,
   isPayloadOfZodType as isPayloadOfZodType2
 } from "@xyo-network/sdk-js";
-import { z as z30 } from "zod";
-var EIP712SignaturePayloadFieldsZod = z30.object({
-  address: z30.string(),
+import { z as z28 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z28.object({
+  address: z28.string(),
   hash: HashZod,
-  signature: z30.string()
+  signature: z28.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -4058,7 +3812,7 @@ var signEIP712Message = async (signer, data) => {
 };
 
 // src/eip-712/verify.ts
-import { asHash as asHash3, isUndefined as isUndefined7 } from "@xylabs/sdk-js";
+import { asHash as asHash3, isUndefined as isUndefined6 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
 import { verifyTypedData } from "ethers";
 var verifyEIP712Message = async (data, sig) => {
@@ -4069,7 +3823,7 @@ var verifyEIP712Message = async (data, sig) => {
   } = sig;
   const { schema, ...fields } = data;
   const signedHash = asHash3(hash);
-  if (isUndefined7(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
+  if (isUndefined6(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 };
@@ -4140,7 +3894,7 @@ import {
   asHash as asHash4,
   assertEx as assertEx33,
   exists as exists3,
-  isDefined as isDefined19,
+  isDefined as isDefined16,
   ZERO_ADDRESS
 } from "@xylabs/sdk-js";
 import {
@@ -4639,7 +4393,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
             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 || isDefined19(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined16(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4758,7 +4512,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
     return await this.spanAsync("qualifiedAccountBalanceHistory", async () => {
       const range = asRange(headOrRange);
       const headHash = asHash4(headOrRange);
-      const [head] = assertEx33(isDefined19(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+      const [head] = assertEx33(isDefined16(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)));
@@ -4772,7 +4526,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
             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 || isDefined19(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined16(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4802,7 +4556,7 @@ SimpleAccountBalanceViewer = __decorateClass([
 import {
   assertEx as assertEx34,
   exists as exists4,
-  isUndefined as isUndefined8
+  isUndefined as isUndefined7
 } from "@xylabs/sdk-js";
 import { LruCacheMap as LruCacheMap2 } from "@xyo-network/xl1-driver-memory";
 import {
@@ -4841,12 +4595,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z31 } from "zod";
+import { z as z29 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z31.ZodError;
+  return error instanceof z29.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z31.prettifyError(error);
+  return z29.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -4916,7 +4670,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   async blockByNumber(blockNumber) {
     return await this.spanAsync("blockByNumber", async () => {
       const chainContext = await this.getChainContextRead();
-      if (isUndefined8(chainContext.head)) {
+      if (isUndefined7(chainContext.head)) {
         return null;
       }
       return await this.blockByNumberWithContext(chainContext, blockNumber);
@@ -4942,7 +4696,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
       assertEx34(limit > 0, () => "limit must be greater than 0");
       assertEx34(limit <= 100, () => "limit must be less than 100");
       const chainContext = await this.getChainContextRead();
-      if (isUndefined8(chainContext.head)) {
+      if (isUndefined7(chainContext.head)) {
         return [];
       }
       const blocks = [];
@@ -4965,7 +4719,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
         () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
       );
       const chainContext = await this.getChainContextRead();
-      if (isUndefined8(chainContext.head)) {
+      if (isUndefined7(chainContext.head)) {
         return [];
       }
       const start = stepIndex * size;
@@ -5341,7 +5095,7 @@ var SimpleXyoClient = class {
 import { assertEx as assertEx37, 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 z32 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { FetchClientError, FetchJsonClient } from "@xylabs/sdk-js";
@@ -5416,7 +5170,7 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.client.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z32.array(PayloadZodLoose).parse(result.data);
+      return z30.array(PayloadZodLoose).parse(result.data);
     }
     return [];
   }
@@ -5693,7 +5447,7 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 import {
   assertEx as assertEx40,
   BigIntToJsonZod,
-  isDefined as isDefined20
+  isDefined as isDefined17
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/sdk-js";
 import {
@@ -5731,9 +5485,9 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
       chain,
       fees
     } = options ?? {};
-    const resolvedChainId = isDefined20(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber10(isDefined20(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber10(isDefined20(exp) ? exp : resolvedNbf + 10, true);
+    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 tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
     return await this.addTransactionToChain(tx, await PayloadBuilder20.addHashMeta(offChain));
   }
@@ -6231,7 +5985,7 @@ SimpleMempoolRunner = __decorateClass([
 import {
   assertEx as assertEx42,
   exists as exists9,
-  isDefined as isDefined21,
+  isDefined as isDefined18,
   isHash as isHash2
 } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle as isPayloadBundle2 } from "@xyo-network/sdk-js";
@@ -6302,7 +6056,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingBlocksArchivist.get([providedCursor]);
-      if (isDefined21(p)) {
+      if (isDefined18(p)) {
         cursor = p._sequence;
       }
     }
@@ -6322,7 +6076,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingTransactionsArchivist.get([providedCursor]);
-      if (isDefined21(p)) {
+      if (isDefined18(p)) {
         cursor = p._sequence;
       }
     }
@@ -6395,7 +6149,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     const hydratedResults = await Promise.all(
       filteredBundles.map(async (bundle3) => {
         const tx = await bundledPayloadToHydratedTransaction(bundle3);
-        return isDefined21(tx) ? { bundle: bundle3, tx } : void 0;
+        return isDefined18(tx) ? { bundle: bundle3, tx } : void 0;
       })
     );
     return hydratedResults.filter(exists9);
@@ -6467,7 +6221,7 @@ function deduplicateWithBundleBySigner(items) {
 }
 
 // src/simple/network/SimpleXyoNetwork.ts
-import { fetchJsonGet, isUndefined as isUndefined9 } from "@xylabs/sdk-js";
+import { fetchJsonGet, isUndefined as isUndefined8 } from "@xylabs/sdk-js";
 import { isNetworkStatus } from "@xyo-network/xl1-protocol-lib";
 
 // src/simple/network/lib/FailedNetworkStatusPayloads.ts
@@ -6515,7 +6269,7 @@ var SimpleXyoNetwork = class {
   }
   async status() {
     const statusNetwork = StatusNetworks[this._networkId];
-    if (isUndefined9(statusNetwork)) {
+    if (isUndefined8(statusNetwork)) {
       throw new Error(`Unknown status network ID: ${this._networkId}`);
     }
     return await this.makeRequest(statusNetwork.statusUrl);
@@ -6701,7 +6455,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
 };
 
 // src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts
-import { isDefined as isDefined22 } from "@xylabs/sdk-js";
+import { isDefined as isDefined19 } from "@xylabs/sdk-js";
 import { StakeEventsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeEventsViewer.defaultMoniker;
@@ -6714,7 +6468,7 @@ var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined22(name)) {
+    if (isDefined19(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -7068,7 +6822,7 @@ RestSyncViewer = __decorateClass([
 import {
   asHash as asHash5,
   assertEx as assertEx47,
-  isDefined as isDefined23
+  isDefined as isDefined20
 } from "@xylabs/sdk-js";
 import {
   asTimePayload as asTimePayload2,
@@ -7092,7 +6846,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         const [block, payloads] = assertEx47(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(isDefined23(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload2(isDefined20(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -7166,7 +6920,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       xl1Hash: assertEx47(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
-    if (isDefined23(this.ethProvider)) {
+    if (isDefined20(this.ethProvider)) {
       const [ethereum, ethHashOrNull] = await this.currentTimeAndHash("ethereum");
       const ethereumHash = asHash5(ethHashOrNull, () => "No ethereum hash available from time sync service");
       timePayload.ethereum = ethereum;
@@ -7670,7 +7424,7 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildBlock.ts
-import { assertEx as assertEx51, isDefined as isDefined24 } from "@xylabs/sdk-js";
+import { assertEx as assertEx51, isDefined as isDefined21 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload5,
   BoundWitnessBuilder as BoundWitnessBuilder3,
@@ -7754,7 +7508,7 @@ function buildStepHashes(blockNumber, inStepHashes, previousBlockHash, chainStep
         completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress2, { [completedStepRewardHolderAddress]: completedStepReward }));
       }
       step_hashes.push(assertEx51(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
-    } else if (isDefined24(inStepHashes.at(i))) {
+    } else if (isDefined21(inStepHashes.at(i))) {
       step_hashes.push(inStepHashes[i]);
     }
   }
@@ -8056,8 +7810,8 @@ var getUrl = (host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z as z33 } from "zod";
-var MnemonicStringZod = z33.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+import { z as z31 } from "zod";
+var MnemonicStringZod = z31.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");
@@ -8134,6 +7888,7 @@ export {
   MemoryTransportConfigZod,
   MissingCapabilityError,
   MnemonicStringZod,
+  MongoConfigZod,
   MongoTransportConfigZod as MongoConnectionConfigZod,
   MongoTransportConfigZod,
   PENDING_BLOCKS_ARCHIVIST_ROLE,
@@ -8150,7 +7905,6 @@ export {
   ProvidersConfigZod,
   REJECTED_BLOCKS_ARCHIVIST_ROLE,
   REJECTED_TRANSACTIONS_ARCHIVIST_ROLE,
-  RemoteConfigZod,
   RestTransportConfigZod as RestConnectionConfigZod,
   RestDataLakeConfigZod,
   RestDataLakeRunner,
@@ -8165,6 +7919,7 @@ export {
   RpcTransportConfigZod,
   RuntimeStatusMonitor,
   RuntimeStatusMonitorZod,
+  S3BucketConfigZod,
   S3TransportConfigZod as S3ConnectionConfigZod,
   S3TransportConfigZod,
   SchemasStepSummarySchema,
@@ -8217,7 +7972,6 @@ export {
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS,
   activeStakeAtTimeByAddress,
   activeStakeAtTimeByPosition,
-  adaptLegacyConfig,
   addDataLakePayloads,
   addDataLakePayloadsToPayloads,
   allHashesPresent,
@@ -8299,8 +8053,6 @@ export {
   generateXyoBaseWalletFromPhrase,
   getArchivistFactory,
   getBlockRateBlocks,
-  getEmptyContext,
-  getEmptyProviderContext,
   getProducerKey,
   getTestProviderContext2 as getTestProviderContext,
   getTestSimpleBlockViewerLocator,
@@ -8309,8 +8061,6 @@ export {
   getWindowedChain,
   hasDeclaredConnectionProfiles,
   hasLabels,
-  hasMongoConfig,
-  hasS3Config,
   hashFromBlockNumber,
   hydrateBlock,
   hydrateElevatedTransaction,
@@ -8374,7 +8124,6 @@ export {
   resolveConfig,
   resolveProviders,
   resolveProvidersFromConfig,
-  resolveS3Bucket,
   rewardFromBlockNumber,
   schemasMaxStep,
   schemasStepSummaryFromRange,
@@ -8393,6 +8142,7 @@ export {
   stepsRewardTotalGenesisPeriod,
   stepsRewardTotalRange,
   surfaceForBranch,
+  synthesizeRpcConnectionBindings,
   timeDurations,
   toActorConfig,
   toActorConfigContext,