@xyo-network/xl1-protocol-sdk 3.0.11 → 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 globalRegistry8, z as z13 } from "zod/mini";
+import { globalRegistry as globalRegistry9, z as z14 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z12 } 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,108 +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({});
+var ConnectionsConfigZod = z5.record(z5.string(), ConnectionConfigZod).default({});
+
+// src/config/connections/RpcRemote.ts
+import { globalRegistry as globalRegistry4, z as z6 } from "zod";
+var RpcRemoteConfigBaseZod = z6.object({
+  protocol: z6.string("http").register(globalRegistry4, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  })
+}).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"
+  }).default("http"),
+  url: z6.string().register(globalRegistry4, {
+    description: "URL for the Chain RPC API",
+    type: "string"
+  })
+}).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"
+  }),
+  sessionId: z6.string().register(globalRegistry4, {
+    description: "Session ID to use for the postMessage RPC connection",
+    type: "string"
+  })
+}).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 globalRegistry4, z as z6 } from "zod";
+import { globalRegistry as globalRegistry5, z as z7 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z6.object({
-  logLevel: z6.enum(LogLevelNames).default("info").register(globalRegistry4, {
+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: z6.boolean().default(false).register(globalRegistry4, {
+  silent: z7.boolean().default(false).register(globalRegistry5, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1884,23 +1899,18 @@ var LogConfigZod = z6.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry5, z as z7 } from "zod";
-var ProviderBindingConfigZod = z7.object({
-  connection: z7.string().optional().register(globalRegistry5, {
+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: z7.string().optional().register(globalRegistry5, {
-    description: "Deprecated alias for connection (kept in sync during migration)",
-    title: "providerBindings.transport",
-    type: "string"
   })
 }).describe("Provider connection binding");
-var ProviderBindingsConfigZod = z7.record(z7.string(), ProviderBindingConfigZod).default({});
+var ProviderBindingsConfigZod = z8.record(z8.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z9 from "zod";
+import z10 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -1908,20 +1918,20 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z8 } from "zod";
-var ProviderConfigZod = z8.object({
-  moniker: z8.string(),
-  labels: z8.array(z8.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 = z9.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 globalRegistry6, z as z10 } from "zod";
+import { globalRegistry as globalRegistry7, z as z11 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -1929,29 +1939,29 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z10.object({
-  path: z10.string().default("/metrics").register(globalRegistry6, {
+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: z10.coerce.number().int().nonnegative().optional().register(globalRegistry6, {
+  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 = z10.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z10.object({
+var MetricsConfigZod = z11.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z11.object({
   // OpenTelemetry options
-  otlpEndpoint: z10.url().optional().register(globalRegistry6, {
+  otlpEndpoint: z11.url().optional().register(globalRegistry7, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z10.object({
+var TelemetryConfigZod = z11.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -1960,7 +1970,7 @@ var TelemetryConfigZod = z10.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
-import { globalRegistry as globalRegistry7, z as z11 } 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";
@@ -2878,24 +2888,24 @@ function findUncles(context, finalizedWindowedChain, blocks) {
 }
 
 // src/config/Validation.ts
-var ValidationConfigZod = z11.object({
-  allowedRewardRedeemers: z11.array(XyoAddressZod2).optional().register(globalRegistry7, {
+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: z11.array(XyoAddressZod2).optional().register(globalRegistry7, {
+  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: z11.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry7, {
+  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: z11.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry7, {
+  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",
@@ -2904,24 +2914,24 @@ var ValidationConfigZod = z11.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z12.object({
-  chain: z12._default(ChainConfigZod, ChainConfigZod.parse({})).check(z12.describe("Configuration for the chain")),
-  log: z12._default(LogConfigZod, LogConfigZod.parse({})).check(z12.describe("Configuration for logging")),
-  connections: z12._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z12.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
-  providerBindings: z12._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z12.describe("Per-moniker provider connection bindings")),
-  providers: z12._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z12.describe("Configuration for providers")),
-  telemetry: z12._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z12.describe("Configuration for telemetry")),
-  validation: z12._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z12.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 = z13.string().check(z13.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 = z13.extend(BaseConfigZod, {
-  name: z13.string(),
-  accountPath: z13.optional(AccountPathZod).register(globalRegistry8, {
+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"
@@ -2932,22 +2942,22 @@ var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z14 } from "zod/mini";
-var ActorsConfigZod = z14._default(
-  z14.array(z14.looseObject(ActorConfigZod.shape)).check(z14.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 globalRegistry9, z as z15 } from "zod/mini";
-var ConfigZod = z15.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry10, z as z16 } from "zod/mini";
+var ConfigZod = z16.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z15.optional(z15.coerce.number()).register(globalRegistry9, {
+  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(z15.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 {
@@ -2956,7 +2966,7 @@ function resolveConfig(config) {
     ...rootConfig
   } = parsedConfig;
   parsedConfig.actors = actors.map((actorConfig) => {
-    return z15.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
+    return z16.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
   });
   return parsedConfig;
 }
@@ -2967,15 +2977,15 @@ import {
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry10, z as z16 } from "zod/mini";
-var HostActorConfigZod = z16.extend(ActorConfigZod, {
-  host: z16._default(z16.string(), "localhost").register(globalRegistry10, {
+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: z16._default(z16.coerce.number(), 8080).register(globalRegistry10, {
+  port: z17._default(z17.coerce.number(), 8080).register(globalRegistry11, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -2996,7 +3006,7 @@ function resolveRestConnectionEndpoint(config, moniker) {
   const normalized = normalizeConnectionsConfig(config);
   const binding = normalized.providerBindings[moniker];
   const connectionName = assertEx21(
-    binding?.connection ?? binding?.transport,
+    binding?.connection,
     () => `Provider "${moniker}" has no providerBindings.connection for REST endpoint resolution`
   );
   const rest = assertEx21(
@@ -3037,45 +3047,11 @@ 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 globalRegistry11, z as z17 } from "zod";
-var RpcRemoteConfigBaseZod = z17.object({
-  protocol: z17.string("http").register(globalRegistry11, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  })
-}).describe("Base configuration for the remote RPC");
-var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z17.string("http").register(globalRegistry11, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z17.string().register(globalRegistry11, {
-    description: "URL for the Chain RPC API",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using Http");
-var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z17.string().register(globalRegistry11, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z17.string().register(globalRegistry11, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z17.string().register(globalRegistry11, {
-    description: "Session ID to use for the postMessage RPC connection",
-    type: "string"
-  })
-}).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z17.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-
 // src/config/UsageMeta.ts
 import { z as z18 } from "zod";
 var DescriptionSchema = z18.string();
@@ -7850,8 +7826,8 @@ export {
   COIN_TYPES,
   ChainIndexingServiceStateSchema,
   ConfigZod,
-  TransportConfigZod as ConnectionConfigZod,
-  TransportsConfigZod as ConnectionsConfigZod,
+  ConnectionConfigZod,
+  ConnectionsConfigZod,
   CreatableProviderContextZod,
   DEFAULT_BACKOFF_MS,
   DEFAULT_MAX_ATTEMPTS,
@@ -7863,8 +7839,7 @@ export {
   EIP712DataPayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
-  EvmRpcTransportConfigZod as EvmConnectionConfigZod,
-  EvmRpcTransportConfigZod,
+  EvmRpcConnectionConfigZod,
   GlobalMetaSchema,
   HostActorConfigContext,
   HostActorConfigZod,
@@ -7872,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,
@@ -7897,21 +7870,18 @@ export {
   ProvidersConfigZod,
   REJECTED_BLOCKS_ARCHIVIST_ROLE,
   REJECTED_TRANSACTIONS_ARCHIVIST_ROLE,
-  RestTransportConfigZod as RestConnectionConfigZod,
+  RestConnectionConfigZod,
   RestDataLakeRunner,
   RestDataLakeViewer,
   RestSyncViewer,
-  RestTransportConfigZod,
   RewardMultipliers,
-  RpcTransportConfigZod as RpcConnectionConfigZod,
+  RpcConnectionConfigZod,
   RpcRemoteConfigBaseZod,
   RpcRemoteConfigZod,
-  RpcTransportConfigZod,
   RuntimeStatusMonitor,
   RuntimeStatusMonitorZod,
   S3BucketConfigZod,
-  S3TransportConfigZod as S3ConnectionConfigZod,
-  S3TransportConfigZod,
+  S3ConnectionConfigZod,
   SchemasStepSummarySchema,
   ShiftedBigInt,
   SimpleAccountBalanceViewer,
@@ -7943,8 +7913,6 @@ export {
   TestGenesisBlockRewardAddress,
   TransactionBuilder,
   TransfersStepSummarySchema,
-  TransportConfigZod,
-  TransportsConfigZod,
   TypedDataDomainZod,
   TypedDataFieldZod,
   TypedDataTypesZod,