@xyo-network/xl1-protocol-sdk 2.1.8 → 2.2.0

package/dist/neutral/index.mjs

@@ -1023,7 +1023,7 @@ function resolveProviders(needs, candidates, ctx, options = {}) {
   const { surviving, rejected: preconditionRejected } = filterByPreconditions(backingFiltered, ctx);
   const rejected = [...backingRejected, ...preconditionRejected];
   const byCapability = groupByCapability(surviving, wanted);
-  const { bindings, selectedById } = pickWinners(wanted, byCapability, rejected, candidates);
+  const { bindings, selectedById } = pickWinners(wanted, byCapability, rejected, candidates, options);
   const selected = topoSort([...selectedById.values()], ctx);
   return {
     bindings,
@@ -1095,11 +1095,19 @@ function groupByCapability(surviving, wanted) {
   }
   return byCapability;
 }
-function pickWinners(wanted, byCapability, rejected, allCandidates) {
+function pickWinners(wanted, byCapability, rejected, allCandidates, options) {
   const bindings = {};
   const selectedById = /* @__PURE__ */ new Map();
   for (const moniker of wanted) {
-    const group = byCapability.get(moniker);
+    let group = byCapability.get(moniker);
+    const pinned = options.implementations?.[moniker];
+    if (pinned) {
+      const pinnedGroup = group?.filter((descriptor) => descriptor.id === pinned);
+      if (!pinnedGroup || pinnedGroup.length === 0) {
+        throw new MissingCapabilityError(moniker, [`requested implementation '${pinned}' not available`]);
+      }
+      group = pinnedGroup;
+    }
     if (!group || group.length === 0) {
       throw new MissingCapabilityError(moniker, reasonsFor(moniker, rejected, allCandidates));
     }
@@ -1162,14 +1170,14 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry13, z as z18 } from "zod/mini";
+import { globalRegistry as globalRegistry14, z as z20 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z17 } from "zod/mini";
+import { z as z19 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
-import { XyoAddressZod } from "@xyo-network/address";
+import { XyoAddressZod } from "@xyo-network/sdk-js";
 import { globalRegistry, z as z2 } from "zod/mini";
 var ChainConfigZod = z2.object({
   id: z2.optional(HexZod).register(globalRegistry, {
@@ -1278,8 +1286,24 @@ var LogConfigZod = z8.object({
   })
 });
 
+// src/config/ProviderBinding.ts
+import { globalRegistry as globalRegistry7, z as z9 } from "zod";
+var ProviderBindingConfigZod = z9.object({
+  implementation: z9.string().optional().register(globalRegistry7, {
+    description: "Installed provider implementation id (descriptor id)",
+    title: "providerBindings.implementation",
+    type: "string"
+  }),
+  transport: z9.string().optional().register(globalRegistry7, {
+    description: "Named transport from the top-level transports map",
+    title: "providerBindings.transport",
+    type: "string"
+  })
+}).describe("Provider implementation and transport binding");
+var ProviderBindingsConfigZod = z9.record(z9.string(), ProviderBindingConfigZod).default({});
+
 // src/config/Providers.ts
-import z10 from "zod";
+import z11 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -1287,148 +1311,144 @@ import {
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
-import { z as z9 } from "zod";
-var ProviderConfigZod = z9.object({
-  moniker: z9.string(),
-  labels: z9.array(z9.string()).optional()
+import { z as z10 } from "zod";
+var ProviderConfigZod = z10.object({
+  moniker: z10.string(),
+  labels: z10.array(z10.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 = z10.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
+var ProvidersConfigZod = z11.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/Remote.ts
-import { globalRegistry as globalRegistry7, z as z11 } from "zod";
-var RpcRemoteConfigBaseZod = z11.object({
-  protocol: z11.string("http").register(globalRegistry7, {
+import { globalRegistry as globalRegistry8, z as z12 } from "zod";
+var RpcRemoteConfigBaseZod = z12.object({
+  protocol: z12.string("http").register(globalRegistry8, {
     description: "Protocol for the RPC connection",
     type: "string"
   })
 }).describe("Base configuration for the remote RPC");
 var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z11.string("http").register(globalRegistry7, {
+  protocol: z12.string("http").register(globalRegistry8, {
     description: "Protocol for the RPC connection",
     type: "string"
   }).default("http"),
-  url: z11.string().register(globalRegistry7, {
+  url: z12.string().register(globalRegistry8, {
     description: "URL for the Chain RPC API",
     type: "string"
   })
 }).describe("Configuration for the remote RPC using Http");
 var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
-  protocol: z11.string().register(globalRegistry7, {
+  protocol: z12.string().register(globalRegistry8, {
     description: "Protocol for the RPC connection",
     type: "string"
   }).default("postMessage"),
-  networkId: z11.string().register(globalRegistry7, {
+  networkId: z12.string().register(globalRegistry8, {
     description: "Network ID to use for the postMessage RPC connection",
     type: "string"
   }),
-  sessionId: z11.string().register(globalRegistry7, {
+  sessionId: z12.string().register(globalRegistry8, {
     description: "Session ID to use for the postMessage RPC connection",
     type: "string"
   })
 }).describe("Configuration for the remote RPC using postMessage");
-var RpcRemoteConfigZod = z11.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
-var RemoteConfigZod = z11.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+var RpcRemoteConfigZod = z12.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z12.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
 
 // src/config/storage/driver/Mongo.ts
 import { isDefined as isDefined4, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry8, z as z12 } from "zod";
+import { globalRegistry as globalRegistry9, z as z13 } from "zod";
 var hasMongoConfig = (config) => {
   if (isUndefined5(config)) return false;
   return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain);
 };
-var MongoConfigZod = z12.object({
+var MongoConfigZod = z13.object({
   // TODO: Create from other arguments
-  connectionString: z12.string().nonempty().optional().register(globalRegistry8, {
+  connectionString: z13.string().nonempty().optional().register(globalRegistry9, {
     description: "MongoDB connection string",
     title: "storage.mongo.connectionString",
     type: "string"
   }),
-  database: z12.string().nonempty().optional().register(globalRegistry8, {
+  database: z13.string().nonempty().optional().register(globalRegistry9, {
     description: "MongoDB database name",
     title: "storage.mongo.database",
     type: "string"
   }),
-  domain: z12.string().nonempty().optional().register(globalRegistry8, {
+  domain: z13.string().nonempty().optional().register(globalRegistry9, {
     description: "MongoDB domain",
     title: "storage.mongo.domain",
     type: "string"
   }),
-  password: z12.string().nonempty().optional().register(globalRegistry8, {
+  password: z13.string().nonempty().optional().register(globalRegistry9, {
     description: "MongoDB password",
     title: "storage.mongo.password",
     type: "string"
   }),
-  username: z12.string().nonempty().optional().register(globalRegistry8, {
+  username: z13.string().nonempty().optional().register(globalRegistry9, {
     description: "MongoDB username",
     title: "storage.mongo.username",
     type: "string"
   })
 });
 
-// src/config/storage/driver/R2.ts
-import { isDefined as isDefined5, isUndefined as isUndefined6 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry9, z as z13 } from "zod";
-var hasR2Config = (config) => {
-  if (isUndefined6(config)) return false;
-  return isDefined5(config.accountId) && isDefined5(config.accessKeyId) && isDefined5(config.secretAccessKey) && isDefined5(config.bucket);
-};
-var R2ConfigZod = z13.object({
-  accessKeyId: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Cloudflare R2 access key id (from an R2 API token)",
-    title: "storage.r2.accessKeyId",
-    type: "string"
-  }),
-  accountId: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Cloudflare account id; determines the R2 endpoint https://<accountId>.r2.cloudflarestorage.com",
-    title: "storage.r2.accountId",
-    type: "string"
-  }),
-  bucket: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Cloudflare R2 bucket name",
-    title: "storage.r2.bucket",
-    type: "string"
-  }),
-  chainStateBucket: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Cloudflare R2 bucket for the mutable chain state (the head pointer); defaults to `bucket` when unset",
-    title: "storage.r2.chainStateBucket",
-    type: "string"
-  }),
-  indexBucket: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Cloudflare R2 bucket for the chain index (the step-summary families); defaults to `bucket` when unset",
-    title: "storage.r2.indexBucket",
-    type: "string"
-  }),
-  prefix: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Optional key prefix namespacing this store within the bucket",
-    title: "storage.r2.prefix",
-    type: "string"
-  }),
-  secretAccessKey: z13.string().nonempty().optional().register(globalRegistry9, {
-    description: "Cloudflare R2 secret access key (from an R2 API token)",
-    title: "storage.r2.secretAccessKey",
-    type: "string"
-  })
+// src/config/storage/driver/S3.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { z as z14 } from "zod";
+var S3BucketConfigZod = z14.object({
+  accessKeyId: z14.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
+  accountId: z14.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
+  bucket: z14.string().nonempty().optional().describe("S3-compatible bucket name"),
+  prefix: z14.string().nonempty().optional().describe("Optional key prefix within the bucket"),
+  readUrl: z14.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
+  secretAccessKey: z14.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
+});
+var S3ConfigZod = z14.object({
+  accessKeyId: z14.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
+  accountId: z14.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: z14.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
+  secretAccessKey: z14.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
 });
+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 (!isDefined5(accessKeyId) || !isDefined5(accountId) || !isDefined5(secretAccessKey) || !isDefined5(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/storage/Storage.ts
-import { globalRegistry as globalRegistry10, z as z14 } from "zod";
-var StorageConfigZod = z14.object({
+import { globalRegistry as globalRegistry10, z as z15 } from "zod";
+var StorageConfigZod = z15.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  r2: R2ConfigZod.optional().describe("Configuration for the Cloudflare R2 storage driver"),
-  root: z14.string().optional().register(globalRegistry10, {
+  root: z15.string().optional().register(globalRegistry10, {
     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");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry11, z as z15 } from "zod";
+import { globalRegistry as globalRegistry11, z as z16 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -1436,38 +1456,89 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z15.object({
-  path: z15.string().default("/metrics").register(globalRegistry11, {
+var MetricsScrapeConfigZod = z16.object({
+  path: z16.string().default("/metrics").register(globalRegistry11, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z15.coerce.number().int().positive().optional().register(globalRegistry11, {
+  port: z16.coerce.number().int().positive().optional().register(globalRegistry11, {
     description: "Port for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.port",
     type: "number"
   })
 }).describe("Metrics scrape configuration");
-var MetricsConfigZod = z15.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z15.object({
+var MetricsConfigZod = z16.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z16.object({
   // OpenTelemetry options
-  otlpEndpoint: z15.url().optional().register(globalRegistry11, {
+  otlpEndpoint: z16.url().optional().register(globalRegistry11, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z15.object({
+var TelemetryConfigZod = z16.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
   otel: OpenTelemetryConfigZod.optional().describe("OpenTelemetry configuration")
 }).describe("Telemetry configuration options");
 
+// src/config/transports/Transport.ts
+import { globalRegistry as globalRegistry12, z as z17 } from "zod";
+var LmdbTransportConfigZod = z17.object({
+  type: z17.literal("lmdb"),
+  root: z17.string().register(globalRegistry12, {
+    description: "Root directory for local LMDB storage",
+    title: "transports.lmdb.root",
+    type: "string"
+  })
+}).describe("LMDB local storage transport");
+var MongoTransportConfigZod = z17.object({
+  type: z17.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: z17.literal("rpc") }).describe("XL1 JSON-RPC transport");
+var RestTransportConfigZod = z17.object({
+  type: z17.literal("rest"),
+  baseUrl: z17.string().register(globalRegistry12, {
+    description: "HTTP base URL for REST reads",
+    title: "transports.rest.baseUrl",
+    type: "string"
+  })
+}).describe("HTTP REST read transport");
+var S3TransportConfigZod = S3BucketConfigZod.extend({
+  type: z17.literal("s3"),
+  accessKeyId: z17.string().optional(),
+  accountId: z17.string().optional(),
+  secretAccessKey: z17.string().optional()
+}).describe("S3-compatible object storage transport");
+var EvmRpcTransportConfigZod = z17.object({
+  type: z17.literal("evm-rpc"),
+  url: z17.string().register(globalRegistry12, {
+    description: "EVM JSON-RPC URL",
+    title: "transports.evm-rpc.url",
+    type: "string"
+  })
+}).describe("EVM JSON-RPC transport");
+var TransportConfigZod = z17.discriminatedUnion("type", [
+  LmdbTransportConfigZod,
+  MongoTransportConfigZod,
+  RpcTransportConfigZod,
+  RestTransportConfigZod,
+  S3TransportConfigZod,
+  EvmRpcTransportConfigZod
+]);
+var TransportsConfigZod = z17.record(z17.string(), TransportConfigZod).default({});
+
 // src/config/Validation.ts
-import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/address";
-import { globalRegistry as globalRegistry12, z as z16 } from "zod";
+import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
+import { globalRegistry as globalRegistry13, z as z18 } from "zod";
 
 // src/primitives/block/range/blockRangeSteps.ts
 import { asXL1BlockNumber as asXL1BlockNumber2, StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
@@ -1713,7 +1784,7 @@ async function getWindowedChain(context, blockViewer, maxWindowSize, previousCha
 
 // src/primitives/chain/step/chainStepRewardAddress.ts
 import { assertEx as assertEx14, exists } from "@xylabs/sdk-js";
-import { toXyoAddress as toXyoAddress2 } from "@xyo-network/address";
+import { toXyoAddress as toXyoAddress2 } from "@xyo-network/sdk-js";
 import {
   asTransfer,
   isTransfer,
@@ -1722,7 +1793,7 @@ import {
 
 // src/primitives/payload/mergeTransfers.ts
 import { hexToBigInt } from "@xylabs/sdk-js";
-import { toXyoAddress } from "@xyo-network/address";
+import { toXyoAddress } from "@xyo-network/sdk-js";
 function mergeTransfers(transfers) {
   const result = {};
   for (const transfer of transfers) {
@@ -1808,7 +1879,9 @@ var asOptionalAddressPairPayload = AsObjectFactory.createOptional(isAddressPairP
 // src/payloads/netBalancesForPayloads.ts
 import { hexToBigInt as hexToBigInt2 } from "@xylabs/sdk-js";
 import { span } from "@xylabs/sdk-js";
-import { toXyoAddress as toXyoAddress3 } from "@xyo-network/address";
+import {
+  toXyoAddress as toXyoAddress3
+} from "@xyo-network/sdk-js";
 import { isTransfer as isTransfer2 } from "@xyo-network/xl1-protocol-lib";
 var netBalancesForPayloads = (context, payloads) => {
   return span("netBalancesForPayloads", () => {
@@ -1829,7 +1902,9 @@ var netBalancesForPayloads = (context, payloads) => {
 // src/payloads/netSchemasForPayloads.ts
 import { hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
 import { span as span2 } from "@xylabs/sdk-js";
-import { toXyoAddress as toXyoAddress4 } from "@xyo-network/address";
+import {
+  toXyoAddress as toXyoAddress4
+} from "@xyo-network/sdk-js";
 import { isTransfer as isTransfer3 } from "@xyo-network/xl1-protocol-lib";
 var netSchemasForPayloads = (context, payloads) => {
   return span2("netSchemasForPayloads", () => {
@@ -2101,7 +2176,7 @@ async function activeStakeAtTimeByAddress(chain, staked, time, staker) {
 }
 
 // src/primitives/stake/activeStakeAtTimeByPosition.ts
-import { isUndefined as isUndefined7 } from "@xylabs/sdk-js";
+import { isUndefined as isUndefined6 } from "@xylabs/sdk-js";
 
 // src/primitives/stake/mergedAddRemoveStakeEventsByPosition.ts
 async function mergedAddRemoveStakeEventsByPosition(chainEvents, range, position) {
@@ -2119,7 +2194,7 @@ async function activeStakeAtTimeByPosition(chainStakeEvents, externalTime, posit
   let result = 0n;
   for (const event of stakeEvents) {
     if (event.time > externalTime) break;
-    if (isUndefined7(position) || position === Number(event.args.id)) {
+    if (isUndefined6(position) || position === Number(event.args.id)) {
       if (event.name === "StakeAdded") {
         result += event.args.amount;
       } else if (event.name === "StakeRemoved") {
@@ -2131,7 +2206,7 @@ async function activeStakeAtTimeByPosition(chainStakeEvents, externalTime, posit
 }
 
 // src/primitives/stake/allStakersForRange.ts
-import { toXyoAddress as toXyoAddress5 } from "@xyo-network/address";
+import { toXyoAddress as toXyoAddress5 } from "@xyo-network/sdk-js";
 async function allStakersForRange(chain, externalRange, staked) {
   const mergedEvents = await mergedAddRemoveStakeEventsByStaker(chain, [0, externalRange[1]], staked);
   const resultWithZeros = {};
@@ -2366,24 +2441,24 @@ function findUncles(context, finalizedWindowedChain, blocks) {
 }
 
 // src/config/Validation.ts
-var ValidationConfigZod = z16.object({
-  allowedRewardRedeemers: z16.array(XyoAddressZod2).optional().register(globalRegistry12, {
+var ValidationConfigZod = z18.object({
+  allowedRewardRedeemers: z18.array(XyoAddressZod2).optional().register(globalRegistry13, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z16.array(XyoAddressZod2).optional().register(globalRegistry12, {
+  allowedRewardEscrowAccountSigners: z18.array(XyoAddressZod2).optional().register(globalRegistry13, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z16.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry12, {
+  minCandidates: z18.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry13, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z16.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry12, {
+  backoffMs: z18.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry13, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -2392,26 +2467,28 @@ var ValidationConfigZod = z16.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z17.object({
-  chain: z17._default(ChainConfigZod, ChainConfigZod.parse({})).check(z17.describe("Configuration for the chain")),
-  dataLake: z17.optional(DataLakeConfigZod).check(z17.describe("Configuration for data lakes")),
-  evm: z17._default(EvmConfigZod, EvmConfigZod.parse({})).check(z17.describe("Configuration for EVM-backed services")),
-  log: z17._default(LogConfigZod, LogConfigZod.parse({})).check(z17.describe("Configuration for logging")),
-  providers: z17._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z17.describe("Configuration for providers")),
-  remote: z17._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z17.describe("Configuration for remote services")),
-  storage: z17._default(StorageConfigZod, StorageConfigZod.parse({})).check(z17.describe("Configuration for the storage")),
-  telemetry: z17._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z17.describe("Configuration for telemetry")),
-  validation: z17._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z17.describe("Configuration for validation"))
+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")),
+  providerBindings: z19._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z19.describe("Per-moniker provider implementation and transport 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("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  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"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z18.string().check(z18.regex(
+var AccountPathZod = z20.string().check(z20.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 = z18.extend(BaseConfigZod, {
-  name: z18.string(),
-  accountPath: z18.optional(AccountPathZod).register(globalRegistry13, {
+var ActorConfigZod = z20.extend(BaseConfigZod, {
+  name: z20.string(),
+  accountPath: z20.optional(AccountPathZod).register(globalRegistry14, {
     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"
@@ -2422,22 +2499,25 @@ var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z19 } from "zod/mini";
-var ActorsConfigZod = z19._default(
-  z19.array(z19.looseObject(ActorConfigZod.shape)).check(z19.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+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")),
   []
 );
 
+// src/config/adaptLegacyConfig.ts
+import { isDefined as isDefined15 } from "@xylabs/sdk-js";
+
 // src/config/Config.ts
-import { globalRegistry as globalRegistry14, z as z20 } from "zod/mini";
-var ConfigZod = z20.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry15, z as z22 } from "zod/mini";
+var ConfigZod = z22.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z20.optional(z20.coerce.number()).register(globalRegistry14, {
+  healthCheckPort: z22.optional(z22.coerce.number()).register(globalRegistry15, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).check(z20.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z22.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 function resolveConfig(config) {
   const parsedConfig = ConfigZod.parse(config);
   const {
@@ -2446,26 +2526,145 @@ function resolveConfig(config) {
     ...rootConfig
   } = parsedConfig;
   parsedConfig.actors = actors.map((actorConfig) => {
-    return z20.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
+    return z22.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 (!isDefined15(entry?.bucket) && !isDefined15(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 synthesizeProviderBindings(transports) {
+  const bindings = {};
+  if (transports[DEFAULT_RPC_TRANSPORT]) {
+    bindings.BlockViewer = { transport: DEFAULT_RPC_TRANSPORT };
+    bindings.MempoolViewer = { transport: DEFAULT_RPC_TRANSPORT };
+    bindings.FinalizationViewer = { transport: DEFAULT_RPC_TRANSPORT };
+    bindings.TransactionViewer = { transport: DEFAULT_RPC_TRANSPORT };
+    bindings.AccountBalanceViewer = { transport: DEFAULT_RPC_TRANSPORT };
+  }
+  if (transports[S3_FINALIZED_TRANSPORT]) {
+    bindings.BlockPublishRunner = { transport: S3_FINALIZED_TRANSPORT };
+  }
+  if (transports[S3_CHAIN_STATE_TRANSPORT]) {
+    bindings.ChainStateViewer = { transport: S3_CHAIN_STATE_TRANSPORT };
+    bindings.ChainStatePublishRunner = { transport: S3_CHAIN_STATE_TRANSPORT };
+  }
+  if (transports[S3_INDEX_TRANSPORT]) {
+    bindings.IndexPublishRunner = { transport: S3_INDEX_TRANSPORT };
+  }
+  return bindings;
+}
+function adaptLegacyConfig(config) {
+  const parsed = ConfigZod.parse(config);
+  if (Object.keys(parsed.transports).length > 0) {
+    return parsed;
+  }
+  const transports = { ...parsed.transports };
+  if (isDefined15(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 (isDefined15(parsed.remote?.rpc)) {
+    transports[DEFAULT_RPC_TRANSPORT] = rpcTransportFromRemote(parsed.remote.rpc);
+  }
+  if (isDefined15(parsed.evm?.jsonRpc?.url)) {
+    transports[DEFAULT_EVM_RPC_TRANSPORT] = { type: "evm-rpc", url: parsed.evm.jsonRpc.url };
+  }
+  if (isDefined15(parsed.storage?.s3)) {
+    Object.assign(transports, synthesizeS3Transports(parsed.storage.s3));
+  }
+  const providerBindings = {
+    ...synthesizeProviderBindings(transports),
+    ...parsed.providerBindings
+  };
+  return ConfigZod.parse({
+    ...parsed,
+    providerBindings,
+    transports
+  });
+}
+
 // src/config/HostActor.ts
 import {
   zodAsFactory as zodAsFactory4,
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry15, z as z21 } from "zod/mini";
-var HostActorConfigZod = z21.extend(ActorConfigZod, {
-  host: z21._default(z21.string(), "localhost").register(globalRegistry15, {
+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",
     type: "string"
   }),
-  port: z21._default(z21.coerce.number(), 8080).register(globalRegistry15, {
+  port: z23._default(z23.coerce.number(), 8080).register(globalRegistry16, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -2477,30 +2676,30 @@ var asHostActorConfig = zodAsFactory4(HostActorConfigZod, "asHostActorConfig");
 var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
 
 // src/config/UsageMeta.ts
-import { z as z22 } from "zod";
-var DescriptionSchema = z22.string();
-var TitleSchema = z22.string();
-var JSONSchemaMetaSchema = z22.object({
-  id: z22.string().optional(),
+import { z as z24 } from "zod";
+var DescriptionSchema = z24.string();
+var TitleSchema = z24.string();
+var JSONSchemaMetaSchema = z24.object({
+  id: z24.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z22.boolean().optional()
-}).catchall(z22.unknown());
+  deprecated: z24.boolean().optional()
+}).catchall(z24.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z22.array(z22.union([z22.string(), z22.number(), z22.literal(true), z22.undefined()])).readonly();
+var ChoicesSchema = z24.array(z24.union([z24.string(), z24.number(), z24.literal(true), z24.undefined()])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z22.unknown().optional(),
+  default: z24.unknown().optional(),
   description: DescriptionSchema,
-  group: z22.string().optional(),
-  hidden: z22.boolean().optional(),
+  group: z24.string().optional(),
+  hidden: z24.boolean().optional(),
   title: TitleSchema,
-  type: z22.union([
-    z22.literal("array"),
-    z22.literal("count"),
-    z22.literal("boolean"),
-    z22.literal("number"),
-    z22.literal("string")
+  type: z24.union([
+    z24.literal("array"),
+    z24.literal("count"),
+    z24.literal("boolean"),
+    z24.literal("number"),
+    z24.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -2513,7 +2712,7 @@ import {
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
-import { z as z24 } from "zod/mini";
+import { z as z26 } from "zod/mini";
 
 // src/model/CreatableProviderContext.zod.ts
 import {
@@ -2522,17 +2721,17 @@ import {
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z23 } from "zod/mini";
-var RuntimeStatusMonitorZod = z23.custom((val) => val && typeof val === "object");
-var ProviderFactoryLocatorZod = z23.lazy(() => z23.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
-var BaseConfigContextZod = z23.extend(CachingContextZod, {
-  config: z23.looseObject(BaseConfigZod.shape),
-  locator: z23.optional(ProviderFactoryLocatorZod)
+import { z as z25 } from "zod/mini";
+var RuntimeStatusMonitorZod = z25.custom((val) => val && typeof val === "object");
+var ProviderFactoryLocatorZod = z25.lazy(() => z25.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
+var BaseConfigContextZod = z25.extend(CachingContextZod, {
+  config: z25.looseObject(BaseConfigZod.shape),
+  locator: z25.optional(ProviderFactoryLocatorZod)
 });
-var CreatableProviderContextZod = z23.lazy(() => z23.extend(BaseConfigContextZod, {
-  _id: z23.optional(z23.string()),
+var CreatableProviderContextZod = z25.lazy(() => z25.extend(BaseConfigContextZod, {
+  _id: z25.optional(z25.string()),
   locator: ProviderFactoryLocatorZod,
-  statusReporter: z23.optional(RuntimeStatusMonitorZod)
+  statusReporter: z25.optional(RuntimeStatusMonitorZod)
 }));
 var isBaseConfigContext = zodIsFactory4(BaseConfigContextZod);
 var asBaseConfigContext = zodAsFactory5(BaseConfigContextZod, "asBaseConfigContext");
@@ -2653,7 +2852,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 // src/transaction/confirmSubmittedTransaction.ts
 import {
   delay,
-  isDefined as isDefined15,
+  isDefined as isDefined16,
   isNumber
 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
@@ -2675,7 +2874,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
   let attempts = 0;
   while (true) {
     const tx = await viewer.transaction.byHash(txHash) ?? void 0;
-    if (isDefined15(tx)) {
+    if (isDefined16(tx)) {
       options?.logger?.debug("Transaction confirmed", txHash);
       return tx;
     } else {
@@ -2990,7 +3189,7 @@ var bundle2 = (root, transaction) => {
 };
 
 // src/context/Actor.ts
-var ActorConfigContext = z24.extend(BaseConfigContextZod, { config: ActorConfigZod });
+var ActorConfigContext = z26.extend(BaseConfigContextZod, { config: ActorConfigZod });
 var isActorConfigContext = zodIsFactory5(ActorConfigContext);
 var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
 var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
@@ -3380,20 +3579,20 @@ import {
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory6
 } from "@xylabs/sdk-js";
-import { z as z25 } from "zod/mini";
-var HostActorConfigContext = z25.extend(BaseConfigContextZod, { config: HostActorConfigZod });
+import { z as 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 isDefined16 } from "@xylabs/sdk-js";
+import { isDefined as isDefined17 } 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 = isDefined16(exp) ? exp : nbf + 1e4;
+  const expiration = isDefined17(exp) ? exp : nbf + 1e4;
   const redeclarationIntent = new PayloadBuilder13({ schema: ChainStakeIntentSchema }).fields({
     from: address,
     intent,
@@ -3422,26 +3621,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 
 // src/eip-712/Types.ts
-import { z as z26 } from "zod";
-var TypedDataDomainZod = z26.object({
-  name: z26.string().nullable().optional(),
-  version: z26.string().nullable().optional(),
-  chainId: z26.union([z26.string(), z26.number(), z26.bigint()]).nullable().optional(),
-  verifyingContract: z26.string().nullable().optional(),
-  salt: z26.union([z26.string(), z26.instanceof(Uint8Array)]).nullable().optional()
+import { z as 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()
 });
-var TypedDataFieldZod = z26.object({
-  name: z26.string(),
-  type: z26.string()
+var TypedDataFieldZod = z28.object({
+  name: z28.string(),
+  type: z28.string()
 });
-var TypedDataTypesZod = z26.record(z26.string(), z26.array(TypedDataFieldZod));
-var TypedDataValueZod = z26.record(z26.string(), z26.any());
+var TypedDataTypesZod = z28.record(z28.string(), z28.array(TypedDataFieldZod));
+var TypedDataValueZod = z28.record(z28.string(), z28.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z27.object({
+var EIP712DataPayloadFieldsZod = z29.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -3459,11 +3658,11 @@ import {
   asSchema as asSchema3,
   isPayloadOfZodType as isPayloadOfZodType2
 } from "@xyo-network/sdk-js";
-import { z as z28 } from "zod";
-var EIP712SignaturePayloadFieldsZod = z28.object({
-  address: z28.string(),
+import { z as z30 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z30.object({
+  address: z30.string(),
   hash: HashZod,
-  signature: z28.string()
+  signature: z30.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -3492,7 +3691,7 @@ var signEIP712Message = async (signer, data) => {
 };
 
 // src/eip-712/verify.ts
-import { asHash as asHash3, isUndefined as isUndefined8 } from "@xylabs/sdk-js";
+import { asHash as asHash3, isUndefined as isUndefined7 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
 import { verifyTypedData } from "ethers";
 var verifyEIP712Message = async (data, sig) => {
@@ -3503,7 +3702,7 @@ var verifyEIP712Message = async (data, sig) => {
   } = sig;
   const { schema, ...fields } = data;
   const signedHash = asHash3(hash);
-  if (isUndefined8(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
+  if (isUndefined7(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 };
@@ -3574,7 +3773,7 @@ import {
   asHash as asHash4,
   assertEx as assertEx33,
   exists as exists3,
-  isDefined as isDefined17,
+  isDefined as isDefined18,
   ZERO_ADDRESS
 } from "@xylabs/sdk-js";
 import {
@@ -3709,7 +3908,7 @@ async function balancesStepSummaryFromRange(context, semaphores, blockViewer, su
 
 // src/summary/primitives/balances/balancesSummary.ts
 import { assertEx as assertEx27, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
-import { asXyoAddress } from "@xyo-network/address";
+import { asXyoAddress } from "@xyo-network/sdk-js";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3,
   asXL1BlockRange as asXL1BlockRange7,
@@ -3995,7 +4194,7 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
 
 // src/summary/primitives/transfers/transfersSummary.ts
 import { assertEx as assertEx32, spanRootAsync as spanRootAsync7 } from "@xylabs/sdk-js";
-import { asXyoAddress as asXyoAddress2 } from "@xyo-network/address";
+import { asXyoAddress as asXyoAddress2 } from "@xyo-network/sdk-js";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta5,
   asXL1BlockRange as asXL1BlockRange9,
@@ -4072,7 +4271,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 || isDefined17(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined18(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4191,7 +4390,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
     return await this.spanAsync("qualifiedAccountBalanceHistory", async () => {
       const range = asRange(headOrRange);
       const headHash = asHash4(headOrRange);
-      const [head] = assertEx33(isDefined17(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+      const [head] = assertEx33(isDefined18(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 blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists3);
@@ -4204,7 +4403,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 || isDefined17(t.transfers[address]));
+        }).filter(exists3).filter((t) => t.from === address || isDefined18(t.transfers[address]));
         if (transfers.length === 0) {
           continue;
         }
@@ -4232,7 +4431,7 @@ SimpleAccountBalanceViewer = __decorateClass([
 import {
   assertEx as assertEx34,
   exists as exists4,
-  isUndefined as isUndefined9
+  isUndefined as isUndefined8
 } from "@xylabs/sdk-js";
 import { LruCacheMap as LruCacheMap2 } from "@xyo-network/xl1-driver-memory";
 import {
@@ -4271,12 +4470,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z29.ZodError;
+  return error instanceof z31.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z29.prettifyError(error);
+  return z31.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -4344,7 +4543,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   async blockByNumber(blockNumber) {
     return await this.spanAsync("blockByNumber", async () => {
       const chainContext = await this.getChainContextRead();
-      if (isUndefined9(chainContext.head)) {
+      if (isUndefined8(chainContext.head)) {
         return null;
       }
       return await this.blockByNumberWithContext(chainContext, blockNumber);
@@ -4370,7 +4569,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 (isUndefined9(chainContext.head)) {
+      if (isUndefined8(chainContext.head)) {
         return [];
       }
       const blocks = [];
@@ -4393,7 +4592,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
         () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
       );
       const chainContext = await this.getChainContextRead();
-      if (isUndefined9(chainContext.head)) {
+      if (isUndefined8(chainContext.head)) {
         return [];
       }
       const start = stepIndex * size;
@@ -4746,7 +4945,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 z30 } from "zod/mini";
+import { z as z32 } from "zod/mini";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { FetchClientError, FetchJsonClient } from "@xylabs/sdk-js";
@@ -4819,7 +5018,7 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.client.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z30.array(PayloadZodLoose).parse(result.data);
+      return z32.array(PayloadZodLoose).parse(result.data);
     } else {
       return [];
     }
@@ -5062,7 +5261,7 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 import {
   assertEx as assertEx39,
   BigIntToJsonZod,
-  isDefined as isDefined18
+  isDefined as isDefined19
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/sdk-js";
 import {
@@ -5100,9 +5299,9 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
       chain,
       fees
     } = options ?? {};
-    const resolvedChainId = isDefined18(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber10(isDefined18(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber10(isDefined18(exp) ? exp : resolvedNbf + 10, true);
+    const resolvedChainId = isDefined19(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = asXL1BlockNumber10(isDefined19(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber10(isDefined19(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
     return await this.addTransactionToChain(tx, await PayloadBuilder20.addHashMeta(offChain));
   }
@@ -5590,7 +5789,7 @@ SimpleMempoolRunner = __decorateClass([
 // src/simple/mempool/SimpleMempoolViewer.ts
 import {
   exists as exists9,
-  isDefined as isDefined19,
+  isDefined as isDefined20,
   isHash as isHash2
 } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle as isPayloadBundle2 } from "@xyo-network/sdk-js";
@@ -5651,7 +5850,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingBlocksArchivist.get([providedCursor]);
-      if (isDefined19(p)) {
+      if (isDefined20(p)) {
         cursor = p._sequence;
       }
     }
@@ -5670,7 +5869,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     let cursor = void 0;
     if (isHash2(providedCursor)) {
       const [p] = await this.pendingTransactionsArchivist.get([providedCursor]);
-      if (isDefined19(p)) {
+      if (isDefined20(p)) {
         cursor = p._sequence;
       }
     }
@@ -5685,7 +5884,7 @@ var SimpleMempoolViewer = class extends AbstractCreatableProvider {
     const hydratedWithBundle = (await Promise.all(
       filteredBundles.map(async (bundle3) => {
         const tx = await bundledPayloadToHydratedTransaction(bundle3);
-        return isDefined19(tx) ? { bundle: bundle3, tx } : void 0;
+        return isDefined20(tx) ? { bundle: bundle3, tx } : void 0;
       })
     )).filter(exists9);
     const currentBlock = await this.windowedBlockViewer.currentBlock();
@@ -5805,7 +6004,7 @@ function deduplicateWithBundleBySigner(items) {
 }
 
 // src/simple/network/SimpleXyoNetwork.ts
-import { fetchJsonGet, isUndefined as isUndefined10 } from "@xylabs/sdk-js";
+import { fetchJsonGet, isUndefined as isUndefined9 } from "@xylabs/sdk-js";
 import { isNetworkStatus } from "@xyo-network/xl1-protocol-lib";
 
 // src/simple/network/lib/FailedNetworkStatusPayloads.ts
@@ -5853,7 +6052,7 @@ var SimpleXyoNetwork = class {
   }
   async status() {
     const statusNetwork = StatusNetworks[this._networkId];
-    if (isUndefined10(statusNetwork)) {
+    if (isUndefined9(statusNetwork)) {
       throw new Error(`Unknown status network ID: ${this._networkId}`);
     }
     return await this.makeRequest(statusNetwork.statusUrl);
@@ -6036,7 +6235,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
 };
 
 // src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts
-import { isDefined as isDefined20 } from "@xylabs/sdk-js";
+import { isDefined as isDefined21 } from "@xylabs/sdk-js";
 import { StakeEventsViewerMoniker } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeEventsViewer.defaultMoniker;
@@ -6049,7 +6248,7 @@ var SimpleStakeEventsViewer = class extends AbstractCreatableProvider {
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined20(name)) {
+    if (isDefined21(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -6115,7 +6314,7 @@ SimpleStakeEventsViewer = __decorateClass([
 
 // src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts
 import { assertEx as assertEx43 } from "@xylabs/sdk-js";
-import { asXyoAddress as asXyoAddress3 } from "@xyo-network/address";
+import { asXyoAddress as asXyoAddress3 } from "@xyo-network/sdk-js";
 import {
   StakeTotalsViewerMoniker,
   StakeViewerMoniker
@@ -6213,7 +6412,7 @@ SimpleStakeTotalsViewer = __decorateClass([
 
 // src/simple/StakeViewer/SimpleStakeViewer.ts
 import { assertEx as assertEx44, toAddress } from "@xylabs/sdk-js";
-import { asXyoAddress as asXyoAddress4 } from "@xyo-network/address";
+import { asXyoAddress as asXyoAddress4 } from "@xyo-network/sdk-js";
 import { StakeEventsViewerMoniker as StakeEventsViewerMoniker2, StakeViewerMoniker as StakeViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeViewer.defaultMoniker;
@@ -6397,7 +6596,7 @@ RestSyncViewer = __decorateClass([
 import {
   asHash as asHash5,
   assertEx as assertEx45,
-  isDefined as isDefined21
+  isDefined as isDefined22
 } from "@xylabs/sdk-js";
 import {
   asTimePayload as asTimePayload2,
@@ -6421,7 +6620,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         const [block, payloads] = assertEx45(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(isDefined21(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload2(isDefined22(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -6494,7 +6693,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       xl1Hash: assertEx45(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
-    if (isDefined21(this.ethProvider)) {
+    if (isDefined22(this.ethProvider)) {
       const [ethereum, ethHashOrNull] = await this.currentTimeAndHash("ethereum");
       const ethereumHash = asHash5(ethHashOrNull, () => "No ethereum hash available from time sync service");
       timePayload.ethereum = ethereum;
@@ -6984,7 +7183,7 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildBlock.ts
-import { assertEx as assertEx49, isDefined as isDefined22 } from "@xylabs/sdk-js";
+import { assertEx as assertEx49, isDefined as isDefined23 } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload5,
   BoundWitnessBuilder as BoundWitnessBuilder3,
@@ -7090,7 +7289,7 @@ async function buildBlock(options) {
       }
       step_hashes.push(assertEx49(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
     } else {
-      if (isDefined22(inStepHashes.at(i))) {
+      if (isDefined23(inStepHashes.at(i))) {
         step_hashes.push(inStepHashes[i]);
       }
     }
@@ -7350,8 +7549,8 @@ var getUrl = (host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z as z31 } from "zod";
-var MnemonicStringZod = z31.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+import { z as z33 } from "zod";
+var MnemonicStringZod = z33.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");
@@ -7406,6 +7605,7 @@ export {
   EIP712DataPayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
+  EvmRpcTransportConfigZod,
   GlobalMetaSchema,
   HostActorConfigContext,
   HostActorConfigZod,
@@ -7413,13 +7613,17 @@ export {
   HydratedBoundWitnessWithStorageMetaZod,
   HydratedCache,
   JSONSchemaMetaSchema,
+  LmdbTransportConfigZod,
   LoggerStatusReporter,
   MemoryPermissionsStore,
   MissingCapabilityError,
   MnemonicStringZod,
+  MongoTransportConfigZod,
   PRODUCER_DIVERSITY_BONUS,
   PayloadLocator,
   PostMessageRpcRemoteConfigZod,
+  ProviderBindingConfigZod,
+  ProviderBindingsConfigZod,
   ProviderConfigZod,
   ProviderFactory,
   ProviderFactoryLocator,
@@ -7430,12 +7634,15 @@ export {
   RestDataLakeRunner,
   RestDataLakeViewer,
   RestSyncViewer,
+  RestTransportConfigZod,
   RewardMultipliers,
   RouterDataLakeConfigZod,
   RpcRemoteConfigBaseZod,
   RpcRemoteConfigZod,
+  RpcTransportConfigZod,
   RuntimeStatusMonitor,
   RuntimeStatusMonitorZod,
+  S3TransportConfigZod,
   SchemasStepSummarySchema,
   ShiftedBigInt,
   SimpleAccountBalanceViewer,
@@ -7467,6 +7674,8 @@ export {
   TestGenesisBlockRewardAddress,
   TransactionBuilder,
   TransfersStepSummarySchema,
+  TransportConfigZod,
+  TransportsConfigZod,
   TypedDataDomainZod,
   TypedDataFieldZod,
   TypedDataTypesZod,
@@ -7482,6 +7691,7 @@ export {
   XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS,
   activeStakeAtTimeByAddress,
   activeStakeAtTimeByPosition,
+  adaptLegacyConfig,
   addDataLakePayloads,
   addDataLakePayloadsToPayloads,
   allHashesPresent,
@@ -7568,7 +7778,7 @@ export {
   getWindowedChain,
   hasLabels,
   hasMongoConfig,
-  hasR2Config,
+  hasS3Config,
   hashFromBlockNumber,
   hydrateBlock,
   hydrateElevatedTransaction,
@@ -7622,6 +7832,7 @@ export {
   registerCreatableProviderFactory,
   resolveConfig,
   resolveProviders,
+  resolveS3Bucket,
   rewardFromBlockNumber,
   schemasMaxStep,
   schemasStepSummaryFromRange,