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

package/dist/neutral/test/index.mjs

@@ -54,15 +54,18 @@ var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
     assertEx(block, () => `block ${hash} not found`)
   ), () => `hash ${hash} is not a BlockBoundWitness`);
   if (maxDepth === 0) return [bw, []];
-  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map((p) => asAnyPayload(p, true));
+  const blockPayloadResults = await chainMap.get(bw.payload_hashes);
+  const blkPayloads = blockPayloadResults.map((p) => asAnyPayload(p, true));
   if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
   if (maxDepth === 1) return [bw, blkPayloads];
   const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
   const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
-  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map((p) => asAnyPayload(p, true));
+  const transactionPayloadResults = await chainMap.get(transactionsPayloadHashes);
+  const transactionsPayloads = transactionPayloadResults.map((p) => asAnyPayload(p, true));
   assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
   const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
-  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map((p) => asAnyPayload(p, true));
+  const allPayloadResults = await chainMap.get([...allPayloadsHashes]);
+  const allPayloads = allPayloadResults.map((p) => asAnyPayload(p, true));
   const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
   if (maxDepth === 2) assertEx(allHashesPresent(
     [...allPayloadsHashes],
@@ -120,7 +123,7 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4 }
 // src/block/primitives/blockFromBlockNumber.ts
 async function blockFromBlockNumber(context, blockNumber) {
   return await spanAsync("blockFromBlockNumber", async () => {
-    const cacheKey = `${blockNumber}`;
+    const cacheKey = String(blockNumber);
     const { chainMap, head } = context;
     return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
       const [result] = await chainMap.get([head._hash]);
@@ -226,35 +229,41 @@ import {
   PayloadBuilder
 } from "@xyo-network/sdk-js";
 import { isExecutable } from "@xyo-network/xl1-protocol-lib";
+async function processElevateOperation(opCode, args, txBw, txPayloads) {
+  const [hash, ...rest] = args;
+  const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads);
+  assertEx2(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
+  if (isHash(hash)) {
+    assertEx2(
+      txBw.payload_hashes.includes(hash),
+      () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
+    );
+    return assertEx2(
+      txPayloadsWithStorageMeta.find((p) => p._hash === hash),
+      () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
+    );
+  }
+  throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
+}
+async function processOperation(opCode, args, txBw, txPayloads) {
+  switch (opCode) {
+    case "elevate": {
+      return await processElevateOperation(opCode, args, txBw, txPayloads);
+    }
+    default: {
+      throw new Error(`Invalid opCode ${opCode}`);
+    }
+  }
+}
 async function validateTransactionsOpcodes(txs) {
   const txElevatedPayloads = [];
   for (const [txBw, txPayloads] of txs) {
     if (isExecutable(txBw)) {
       const operations = txBw.script.map((op) => op.split("|"));
       for (const [opCode, ...args] of operations) {
-        switch (opCode) {
-          case "elevate": {
-            const [hash, ...rest] = args;
-            const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads);
-            assertEx2(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
-            if (isHash(hash)) {
-              assertEx2(
-                txBw.payload_hashes.includes(hash),
-                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
-              );
-              const txPayload = assertEx2(
-                txPayloadsWithStorageMeta.find((p) => p._hash === hash),
-                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
-              );
-              txElevatedPayloads.push(txPayload);
-            } else {
-              throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
-            }
-            break;
-          }
-          default: {
-            throw new Error(`Invalid opCode ${opCode}`);
-          }
+        const txPayload = await processOperation(opCode, args, txBw, txPayloads);
+        if (txPayload !== void 0) {
+          txElevatedPayloads.push(txPayload);
         }
       }
     }
@@ -292,12 +301,14 @@ import { toHex } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
 import { TransferSchema } from "@xyo-network/xl1-protocol-lib";
 function createTransferPayload(from, transfers, context) {
-  return new PayloadBuilder2({ schema: TransferSchema }).fields({
+  const payloadBuilder = new PayloadBuilder2({ schema: TransferSchema });
+  const builder = payloadBuilder.fields({
     epoch: Date.now(),
     from,
     transfers: Object.fromEntries(Object.entries(transfers).map(([k, v]) => [k, toHex(v)])),
     context
-  }).build();
+  });
+  return builder.build();
 }
 
 // src/test/BuildBlockOptions.ts
@@ -352,6 +363,26 @@ var isBuildNextBlockOptions = (value) => {
 function calculateCompletedStepReward(step, balance) {
   return AttoXL1(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1]);
 }
+function buildStepHashes(blockNumber, inStepHashes, previousBlockHash, chainStepRewardAddress, stepRewardPoolBalance) {
+  const completedStepRewardTransfers = [];
+  const step_hashes = [];
+  for (const [i, step] of StepSizes3.entries()) {
+    if (blockNumber < step) {
+      break;
+    }
+    if (blockNumber % step === 0) {
+      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress !== XYO_ZERO_ADDRESS) {
+        const completedStepRewardHolderAddress = rewardAddressFromStepIdentity({ block: blockNumber, step });
+        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
+        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }));
+      }
+      step_hashes.push(assertEx3(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+    } else if (isDefined3(inStepHashes.at(i))) {
+      step_hashes.push(inStepHashes[i]);
+    }
+  }
+  return { completedStepRewardTransfers, step_hashes };
+}
 async function buildBlock(options) {
   const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
   const blockNumber = asXL1BlockNumber2(previousBlockNumber + 1, true);
@@ -366,7 +397,6 @@ async function buildBlock(options) {
     protocol = XL1_PROTOCOL_VERSION,
     signers
   } = options;
-  const step_hashes = [];
   for (const [tx] of txs) {
     if (tx.nbf > blockNumber) {
       throw new Error(`Transaction ${await PayloadBuilder3.hash(tx)} not valid for block ${blockNumber} - NBF is ${tx.nbf}`);
@@ -375,24 +405,13 @@ async function buildBlock(options) {
       throw new Error(`Transaction ${await PayloadBuilder3.hash(tx)} not valid for block ${blockNumber} - EXP is ${tx.exp}`);
     }
   }
-  const completedStepRewardTransfers = [];
-  for (const [i, step] of StepSizes3.entries()) {
-    if (blockNumber < step) {
-      break;
-    }
-    if (blockNumber % step === 0) {
-      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress !== XYO_ZERO_ADDRESS) {
-        const completedStepRewardHolderAddress = rewardAddressFromStepIdentity({ block: blockNumber, step });
-        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
-        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }));
-      }
-      step_hashes.push(assertEx3(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
-    } else {
-      if (isDefined3(inStepHashes.at(i))) {
-        step_hashes.push(inStepHashes[i]);
-      }
-    }
-  }
+  const { step_hashes, completedStepRewardTransfers } = buildStepHashes(
+    blockNumber,
+    inStepHashes,
+    previousBlockHash,
+    chainStepRewardAddress,
+    stepRewardPoolBalance
+  );
   const previous = previousBlockHash ?? null;
   const block = blockNumber;
   const txElevatedPayloads = await validateTransactionsOpcodes(txs);
@@ -402,13 +421,15 @@ async function buildBlock(options) {
     ...txElevatedPayloads,
     ...completedStepRewardTransfers
   ];
-  const [bw, txPayloads] = await new BoundWitnessBuilder().fields({
+  const boundWitnessBuilder = new BoundWitnessBuilder();
+  const builder = boundWitnessBuilder.fields({
     block,
     chain: chainId,
     previous,
     step_hashes,
     protocol
-  }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder3.addStorageMeta(payloads)).build();
+  }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder3.addStorageMeta(payloads));
+  const [bw, txPayloads] = await builder.build();
   assertEx3(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
   return [await PayloadBuilder3.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload2(p, true))];
 }
@@ -484,10 +505,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     exp
   };
   const elevatedHashes = await PayloadBuilder4.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
-  }
+  const script = Array.from(elevatedHashes, (elevatedHash) => `elevate|${elevatedHash}`);
   const fields = {
     ...txBoundWitnessFields,
     from: from ?? (Array.isArray(signer) ? assertEx4(signer.at(0)?.address) : signer.address)
@@ -495,7 +513,9 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   if (script.length > 0) {
     fields.script = script;
   }
-  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
+  const boundWitnessBuilder = new BoundWitnessBuilder2();
+  const builder = boundWitnessBuilder.fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]);
+  const [tx, txPayloads] = await builder.build();
   return [await PayloadBuilder4.addHashMeta(tx), await PayloadBuilder4.addHashMeta(txPayloads.map((p) => asAnyPayload3(p, true)))];
 }
 
@@ -505,7 +525,8 @@ var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNu
   const additionalPayloads = (payloads ?? []).filter((payload) => !isAllowedBlockPayload(payload));
   const sender = account ?? await Account.random();
   if (elevatedPayloads.length === 0) {
-    const receiver = receiverAddress ?? (await Account.random()).address;
+    const defaultReceiver = await Account.random();
+    const receiver = receiverAddress ?? defaultReceiver.address;
     const transferPayload = createTransferPayload(sender.address, { [receiver]: 1n });
     elevatedPayloads.push(transferPayload);
   }
@@ -536,12 +557,14 @@ import {
   defaultTransactionFees as defaultTransactionFees2
 } from "@xyo-network/xl1-protocol-lib";
 async function createProducerChainStakeIntent(from, exp, nbf = 0) {
-  return await PayloadBuilder6.addHashMeta(new PayloadBuilder6({ schema: ChainStakeIntentSchema }).fields({
+  const payloadBuilder = new PayloadBuilder6({ schema: ChainStakeIntentSchema });
+  const builder = payloadBuilder.fields({
     from,
     exp,
     nbf,
     intent: "producer"
-  }).build());
+  });
+  return await PayloadBuilder6.addHashMeta(builder.build());
 }
 
 // src/test/createGenesisBlock.ts
@@ -585,13 +608,20 @@ var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId,
     remaining = remaining - 1;
     lastBlock = block;
   }
-  const resolvedReceiverAddresses = receiverAddresses ?? [(await Account3.random()).address];
+  const defaultReceiver = await Account3.random();
+  const resolvedReceiverAddresses = receiverAddresses ?? [defaultReceiver.address];
   let saltCounter = 0;
   while (remaining > 0) {
     saltCounter += 1;
-    const payloads = [new PayloadBuilder8({ schema: IdSchema2 }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()];
+    const idPayloadBuilder = new PayloadBuilder8({ schema: IdSchema2 });
+    const idBuilder = idPayloadBuilder.fields({ salt: `${Date.now()}-${saltCounter}` });
+    const payloads = [idBuilder.build()];
     saltCounter += 1;
-    const additionalPrivatePayloads = remaining % 2 === 0 ? [new PayloadBuilder8({ schema: asSchema2("network.xyo.private", true) }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()] : [];
+    const additionalPrivatePayloads = remaining % 2 === 0 ? (() => {
+      const privatePayloadBuilder = new PayloadBuilder8({ schema: asSchema2("network.xyo.private", true) });
+      const privateBuilder = privatePayloadBuilder.fields({ salt: `${Date.now()}-${saltCounter}` });
+      return [privateBuilder.build()];
+    })() : [];
     const txs = [];
     for (const receiverAddress of resolvedReceiverAddresses) {
       txs.push(await buildRandomTransaction(
@@ -661,7 +691,7 @@ var ProviderFactory = class _ProviderFactory {
   get resolvedMoniker() {
     const labels = this.labels ?? {};
     const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
-    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`;
+    return labelString.length === 0 ? this.defaultMoniker : `${this.defaultMoniker}|${labelString}`;
   }
   get uniqueId() {
     return this._uniqueId;
@@ -676,8 +706,7 @@ var ProviderFactory = class _ProviderFactory {
     let scopeObject;
     switch (this.scope) {
       case "global": {
-        globalThis.xyoServiceSingletons ??= {};
-        scopeObject = globalThis.xyoServiceSingletons;
+        scopeObject = getOrCreateGlobalSingletons();
         break;
       }
       case "context": {
@@ -714,6 +743,15 @@ var ProviderFactory = class _ProviderFactory {
     }
   }
 };
+function getOrCreateGlobalSingletons() {
+  const existing = globalThis.xyoServiceSingletons;
+  if (existing !== void 0) {
+    return existing;
+  }
+  const singletons = {};
+  Reflect.set(globalThis, "xyoServiceSingletons", singletons);
+  return singletons;
+}
 
 // src/CreatableProvider/AbstractCreatableProvider.ts
 var AbstractCreatableProvider = class extends AbstractCreatable {
@@ -883,7 +921,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
     );
   }
   has(moniker) {
-    return !!this._registry[moniker];
+    return Object.hasOwn(this._registry, moniker);
   }
   /**
    * Locates a provider factory that matches the supplied moniker and labels
@@ -900,10 +938,11 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
   merge(locator) {
     const registry = { ...this.registry };
     for (const moniker in locator.registry) {
-      if (registry[moniker]) {
-        registry[moniker].push(...locator.registry[moniker] ?? []);
-      } else {
+      const existing = registry[moniker];
+      if (existing === void 0) {
         registry[moniker] = locator.registry[moniker];
+      } else {
+        existing.push(...locator.registry[moniker] ?? []);
       }
     }
     return new _ProviderFactoryLocator(this.context, registry);
@@ -933,13 +972,13 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
     return this;
   }
   registered(moniker) {
-    return !!this.registry[moniker] || (this._parent?.registered(moniker) ?? false);
+    return Object.hasOwn(this.registry, moniker) || (this._parent?.registered(moniker) ?? false);
   }
   async tryGetInstance(moniker, { start = true, labels } = {}) {
     const resolvedParams = { context: this.context };
     const factory = this.tryLocate(moniker, labels);
-    if (factory) {
-      if (this.context.singletons[factory.uniqueId]) {
+    if (factory !== void 0) {
+      if (Object.hasOwn(this.context.singletons, factory.uniqueId)) {
         return this.context.singletons[factory.uniqueId];
       }
       this.logger?.debug(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ""} using factory [${factory.uniqueId.description}]`);
@@ -1012,16 +1051,167 @@ var ChainConfigZod = z.object({
   })
 });
 
+// src/config/transports/Transport.ts
+import { globalRegistry as globalRegistry4, z as z5 } from "zod";
+
+// src/config/Remote.ts
+import { globalRegistry as globalRegistry2, z as z2 } from "zod";
+var RpcRemoteConfigBaseZod = z2.object({
+  protocol: z2.string("http").register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  })
+}).describe("Base configuration for the remote RPC");
+var HttpRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z2.string("http").register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("http"),
+  url: z2.string().register(globalRegistry2, {
+    description: "URL for the Chain RPC API",
+    type: "string"
+  })
+}).describe("Configuration for the remote RPC using Http");
+var PostMessageRpcRemoteConfigZod = RpcRemoteConfigBaseZod.extend({
+  protocol: z2.string().register(globalRegistry2, {
+    description: "Protocol for the RPC connection",
+    type: "string"
+  }).default("postMessage"),
+  networkId: z2.string().register(globalRegistry2, {
+    description: "Network ID to use for the postMessage RPC connection",
+    type: "string"
+  }),
+  sessionId: z2.string().register(globalRegistry2, {
+    description: "Session ID to use for the postMessage RPC connection",
+    type: "string"
+  })
+}).describe("Configuration for the remote RPC using postMessage");
+var RpcRemoteConfigZod = z2.union([HttpRpcRemoteConfigZod, PostMessageRpcRemoteConfigZod]).describe("Configuration for a remote RPC connection, either Http or postMessage");
+var RemoteConfigZod = z2.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
+
+// src/config/storage/driver/Mongo.ts
+import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+var MongoConfigZod = z3.object({
+  // TODO: Create from other arguments
+  connectionString: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB connection string",
+    title: "storage.mongo.connectionString",
+    type: "string"
+  }),
+  database: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB database name",
+    title: "storage.mongo.database",
+    type: "string"
+  }),
+  domain: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB domain",
+    title: "storage.mongo.domain",
+    type: "string"
+  }),
+  password: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB password",
+    title: "storage.mongo.password",
+    type: "string"
+  }),
+  username: z3.string().nonempty().optional().register(globalRegistry3, {
+    description: "MongoDB username",
+    title: "storage.mongo.username",
+    type: "string"
+  })
+});
+
+// src/config/storage/driver/S3.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { z as z4 } from "zod";
+var S3BucketConfigZod = z4.object({
+  accessKeyId: z4.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
+  accountId: z4.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
+  bucket: z4.string().nonempty().optional().describe("S3-compatible bucket name"),
+  prefix: z4.string().nonempty().optional().describe("Optional key prefix within the bucket"),
+  readUrl: z4.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
+  secretAccessKey: z4.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
+});
+var S3ConfigZod = z4.object({
+  accessKeyId: z4.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
+  accountId: z4.string().nonempty().optional().describe("Shared account id (default for all buckets; on Cloudflare R2 it forms the endpoint)"),
+  chainState: S3BucketConfigZod.optional().describe("Bucket for the mutable chain state (the head pointer)"),
+  finalized: S3BucketConfigZod.optional().describe("Bucket for the finalized files (blocks, payloads, manifest)"),
+  index: S3BucketConfigZod.optional().describe("Bucket for the chain index (the step-summary families)"),
+  prefix: z4.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
+  secretAccessKey: z4.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
+});
+
+// src/config/transports/Transport.ts
+var LmdbTransportConfigZod = z5.object({
+  access: z5.enum(["read", "write"]).optional().register(globalRegistry4, {
+    description: "Access mode for this LMDB connection (read or write)",
+    title: "transports.lmdb.access",
+    type: "string"
+  }),
+  root: z5.string().register(globalRegistry4, {
+    description: "Root directory for local LMDB storage",
+    title: "transports.lmdb.root",
+    type: "string"
+  }),
+  store: z5.string().optional().register(globalRegistry4, {
+    description: "Logical store name within the LMDB root (e.g. finalized-chain, mempool)",
+    title: "transports.lmdb.store",
+    type: "string"
+  }),
+  type: z5.literal("lmdb")
+}).describe("LMDB local storage transport");
+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: z5.literal("rpc") }).describe("XL1 JSON-RPC transport");
+var RestTransportConfigZod = z5.object({
+  type: z5.literal("rest"),
+  baseUrl: z5.string().register(globalRegistry4, {
+    description: "HTTP base URL for REST reads",
+    title: "transports.rest.baseUrl",
+    type: "string"
+  })
+}).describe("HTTP REST read transport");
+var S3TransportConfigZod = S3BucketConfigZod.extend({
+  type: z5.literal("s3"),
+  accessKeyId: z5.string().optional(),
+  accountId: z5.string().optional(),
+  secretAccessKey: z5.string().optional()
+}).describe("S3-compatible object storage transport");
+var EvmRpcTransportConfigZod = z5.object({
+  type: z5.literal("evm-rpc"),
+  url: z5.string().register(globalRegistry4, {
+    description: "EVM JSON-RPC URL",
+    title: "transports.evm-rpc.url",
+    type: "string"
+  })
+}).describe("EVM JSON-RPC transport");
+var TransportConfigZod = z5.discriminatedUnion("type", [
+  LmdbTransportConfigZod,
+  MongoTransportConfigZod,
+  RpcTransportConfigZod,
+  RestTransportConfigZod,
+  S3TransportConfigZod,
+  EvmRpcTransportConfigZod
+]);
+var TransportsConfigZod = z5.record(z5.string(), TransportConfigZod).default({});
+
 // src/config/DataLake/DataLake.ts
-import { z as z5 } from "zod";
+import { z as z9 } from "zod";
 
 // src/config/DataLake/RestDataLakeConfig.ts
-import { globalRegistry as globalRegistry3, z as z3 } from "zod";
+import { globalRegistry as globalRegistry6, z as z7 } from "zod";
 
 // src/config/DataLake/DataLakeRemoteConfig.ts
-import { globalRegistry as globalRegistry2, z as z2 } from "zod";
-var DataLakeDriverConfigBaseZod = z2.object({
-  driver: z2.string().register(globalRegistry2, {
+import { globalRegistry as globalRegistry5, z as z6 } from "zod";
+var DataLakeDriverConfigBaseZod = z6.object({
+  driver: z6.string().register(globalRegistry5, {
     description: "Driver for the data lake",
     type: "string"
   })
@@ -1029,55 +1219,55 @@ var DataLakeDriverConfigBaseZod = z2.object({
 
 // src/config/DataLake/RestDataLakeConfig.ts
 var RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z3.literal("rest").register(globalRegistry3, {
+  driver: z7.literal("rest").register(globalRegistry6, {
     description: "Driver for the REST data lake",
     type: "string"
   }),
-  url: z3.string().register(globalRegistry3, {
+  url: z7.string().register(globalRegistry6, {
     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 globalRegistry4, z as z4 } from "zod";
-var RouterDataLakeConfigZod = z4.object({
-  driver: z4.literal("router").register(globalRegistry4, {
+import { globalRegistry as globalRegistry7, z as z8 } from "zod";
+var RouterDataLakeConfigZod = z8.object({
+  driver: z8.literal("router").register(globalRegistry7, {
     description: "Driver for the router data lake",
     type: "string"
   }),
-  children: z4.array(z4.lazy(() => DataLakeConfigZod)).register(globalRegistry4, {
+  children: z8.array(z8.lazy(() => DataLakeConfigZod)).register(globalRegistry7, {
     description: "Child data lake drivers",
     type: "array"
   })
 }).describe("Configuration for the router data lake driver");
 
 // src/config/DataLake/DataLake.ts
-var DataLakeConfigZod = z5.lazy(() => z5.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
+var DataLakeConfigZod = z9.lazy(() => z9.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe("Configuration for a data lake");
 
 // src/config/Evm.ts
-import { globalRegistry as globalRegistry5, z as z6 } from "zod";
-var EvmInfuraConfigZod = z6.object({
-  projectId: z6.string().optional().register(globalRegistry5, {
+import { globalRegistry as globalRegistry8, z as z10 } from "zod";
+var EvmInfuraConfigZod = z10.object({
+  projectId: z10.string().optional().register(globalRegistry8, {
     description: "Infura project ID",
     title: "evm.infura.projectId",
     type: "string"
   }),
-  projectSecret: z6.string().optional().register(globalRegistry5, {
+  projectSecret: z10.string().optional().register(globalRegistry8, {
     description: "Infura project secret",
     title: "evm.infura.projectSecret",
     type: "string"
   })
 });
-var EvmJsonRpcConfigZod = z6.object({
-  url: z6.url().optional().register(globalRegistry5, {
+var EvmJsonRpcConfigZod = z10.object({
+  url: z10.url().optional().register(globalRegistry8, {
     description: "JSON-RPC URL",
     title: "evm.jsonRpc.url",
     type: "string"
   })
 });
-var EvmConfigZod = z6.object({
-  chainId: z6.string().optional().register(globalRegistry5, {
+var EvmConfigZod = z10.object({
+  chainId: z10.string().optional().register(globalRegistry8, {
     description: "EVM chain ID",
     title: "evm.chainId",
     type: "string"
@@ -1088,17 +1278,17 @@ var EvmConfigZod = z6.object({
 
 // src/config/Log.ts
 import { LogLevel } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry6, z as z7 } from "zod";
+import { globalRegistry as globalRegistry9, z as z11 } from "zod";
 var LogLevelNames = Object.keys(LogLevel);
-var LogConfigZod = z7.object({
-  logLevel: z7.enum(LogLevelNames).default("info").register(globalRegistry6, {
+var LogConfigZod = z11.object({
+  logLevel: z11.enum(LogLevelNames).default("info").register(globalRegistry9, {
     choices: LogLevelNames,
     default: "info",
     description: "Desired process verbosity",
     title: "logLevel",
     type: "string"
   }),
-  silent: z7.boolean().default(false).register(globalRegistry6, {
+  silent: z11.boolean().default(false).register(globalRegistry9, {
     default: false,
     description: "Whether to run in silent mode",
     title: "silent",
@@ -1107,23 +1297,23 @@ var LogConfigZod = z7.object({
 });
 
 // src/config/ProviderBinding.ts
-import { globalRegistry as globalRegistry7, z as z8 } from "zod";
-var ProviderBindingConfigZod = z8.object({
-  implementation: z8.string().optional().register(globalRegistry7, {
-    description: "Installed provider implementation id (descriptor id)",
-    title: "providerBindings.implementation",
+import { globalRegistry as globalRegistry10, z as z12 } from "zod";
+var ProviderBindingConfigZod = z12.object({
+  connection: z12.string().optional().register(globalRegistry10, {
+    description: "Named connection from the top-level connections map",
+    title: "providerBindings.connection",
     type: "string"
   }),
-  transport: z8.string().optional().register(globalRegistry7, {
-    description: "Named transport from the top-level transports map",
+  transport: z12.string().optional().register(globalRegistry10, {
+    description: "Deprecated alias for connection (kept in sync during migration)",
     title: "providerBindings.transport",
     type: "string"
   })
-}).describe("Provider implementation and transport binding");
-var ProviderBindingsConfigZod = z8.record(z8.string(), ProviderBindingConfigZod).default({});
+}).describe("Provider connection binding");
+var ProviderBindingsConfigZod = z12.record(z12.string(), ProviderBindingConfigZod).default({});
 
 // src/config/Providers.ts
-import z10 from "zod";
+import z14 from "zod";
 
 // src/config/Provider.ts
 import {
@@ -1131,111 +1321,23 @@ 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 z13 } from "zod";
+var ProviderConfigZod = z13.object({
+  moniker: z13.string(),
+  labels: z13.array(z13.string()).optional()
 }).describe("Configuration for a Provider");
 var isProviderConfig = zodIsFactory(ProviderConfigZod);
 var asProviderConfig = zodAsFactory(ProviderConfigZod, "asProviderConfig");
 var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
 
 // src/config/Providers.ts
-var ProvidersConfigZod = z10.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
-
-// src/config/Remote.ts
-import { globalRegistry as globalRegistry8, z as z11 } from "zod";
-var RpcRemoteConfigBaseZod = z11.object({
-  protocol: z11.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(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("http"),
-  url: z11.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(globalRegistry8, {
-    description: "Protocol for the RPC connection",
-    type: "string"
-  }).default("postMessage"),
-  networkId: z11.string().register(globalRegistry8, {
-    description: "Network ID to use for the postMessage RPC connection",
-    type: "string"
-  }),
-  sessionId: z11.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");
-
-// src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry9, z as z12 } from "zod";
-var MongoConfigZod = z12.object({
-  // TODO: Create from other arguments
-  connectionString: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB connection string",
-    title: "storage.mongo.connectionString",
-    type: "string"
-  }),
-  database: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB database name",
-    title: "storage.mongo.database",
-    type: "string"
-  }),
-  domain: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB domain",
-    title: "storage.mongo.domain",
-    type: "string"
-  }),
-  password: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB password",
-    title: "storage.mongo.password",
-    type: "string"
-  }),
-  username: z12.string().nonempty().optional().register(globalRegistry9, {
-    description: "MongoDB username",
-    title: "storage.mongo.username",
-    type: "string"
-  })
-});
-
-// src/config/storage/driver/S3.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { z as z13 } from "zod";
-var S3BucketConfigZod = z13.object({
-  accessKeyId: z13.string().nonempty().optional().describe("S3-compatible access key id for this bucket (overrides the shared default)"),
-  accountId: z13.string().nonempty().optional().describe("Account id for this bucket; on Cloudflare R2 it forms the endpoint (overrides the shared default)"),
-  bucket: z13.string().nonempty().optional().describe("S3-compatible bucket name"),
-  prefix: z13.string().nonempty().optional().describe("Optional key prefix within the bucket"),
-  readUrl: z13.string().nonempty().optional().describe("Public HTTP/CDN base URL for anonymous reads of this bucket"),
-  secretAccessKey: z13.string().nonempty().optional().describe("S3-compatible secret access key for this bucket (overrides the shared default)")
-});
-var S3ConfigZod = z13.object({
-  accessKeyId: z13.string().nonempty().optional().describe("Shared S3-compatible access key id (default for all buckets)"),
-  accountId: z13.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: z13.string().nonempty().optional().describe("Shared key prefix (default for all buckets)"),
-  secretAccessKey: z13.string().nonempty().optional().describe("Shared S3-compatible secret access key (default for all buckets)")
-});
+var ProvidersConfigZod = z14.array(ProviderConfigZod.loose()).describe("Configuration for providers").default([]);
 
 // src/config/storage/Storage.ts
-import { globalRegistry as globalRegistry10, z as z14 } from "zod";
-var StorageConfigZod = z14.object({
+import { globalRegistry as globalRegistry11, z as z15 } from "zod";
+var StorageConfigZod = z15.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z14.string().optional().register(globalRegistry10, {
+  root: z15.string().optional().register(globalRegistry11, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -1244,87 +1346,36 @@ var StorageConfigZod = z14.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry11, z as z15 } from "zod";
-var MetricsScrapeConfigZod = z15.object({
-  path: z15.string().default("/metrics").register(globalRegistry11, {
+import { globalRegistry as globalRegistry12, z as z16 } from "zod";
+var MetricsScrapeConfigZod = z16.object({
+  path: z16.string().default("/metrics").register(globalRegistry12, {
     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(globalRegistry12, {
     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(globalRegistry12, {
     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 z16 } from "zod";
-var LmdbTransportConfigZod = z16.object({
-  type: z16.literal("lmdb"),
-  root: z16.string().register(globalRegistry12, {
-    description: "Root directory for local LMDB storage",
-    title: "transports.lmdb.root",
-    type: "string"
-  })
-}).describe("LMDB local storage transport");
-var MongoTransportConfigZod = z16.object({
-  type: z16.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: z16.literal("rpc") }).describe("XL1 JSON-RPC transport");
-var RestTransportConfigZod = z16.object({
-  type: z16.literal("rest"),
-  baseUrl: z16.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: z16.literal("s3"),
-  accessKeyId: z16.string().optional(),
-  accountId: z16.string().optional(),
-  secretAccessKey: z16.string().optional()
-}).describe("S3-compatible object storage transport");
-var EvmRpcTransportConfigZod = z16.object({
-  type: z16.literal("evm-rpc"),
-  url: z16.string().register(globalRegistry12, {
-    description: "EVM JSON-RPC URL",
-    title: "transports.evm-rpc.url",
-    type: "string"
-  })
-}).describe("EVM JSON-RPC transport");
-var TransportConfigZod = z16.discriminatedUnion("type", [
-  LmdbTransportConfigZod,
-  MongoTransportConfigZod,
-  RpcTransportConfigZod,
-  RestTransportConfigZod,
-  S3TransportConfigZod,
-  EvmRpcTransportConfigZod
-]);
-var TransportsConfigZod = z16.record(z16.string(), TransportConfigZod).default({});
-
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-js";
 import { globalRegistry as globalRegistry13, z as z17 } from "zod";
@@ -1454,7 +1505,9 @@ var DEFAULT_MAX_ATTEMPTS = 10;
 var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
   assertEx12(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
   const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
-  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock[0] : (await viewer.currentBlock())[0];
+  const currentBlockResult = await viewer.currentBlock();
+  const blockResult = isDefinedNotNull(startBlock) ? startBlock : currentBlockResult;
+  const resolvedStartBlock = blockResult[0];
   const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
   assertEx12(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
   const blocksPerMillisecondRate = 1 / (12 * 1e3);
@@ -1519,7 +1572,7 @@ var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBl
 // src/primitives/state/findMostRecentBlock.ts
 import { isSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
 var DEFAULT_NEXT_OPTIONS = { limit: 50 };
-var findMostRecentBlock = async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTIONS, maxIterations = Number.POSITIVE_INFINITY) => {
+var findMostRecentBlock = async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTIONS, maxIterations = Infinity) => {
   let mostRecentBlock;
   let cursor;
   let batch;
@@ -1535,9 +1588,8 @@ var findMostRecentBlock = async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTI
     if (last) {
       mostRecentBlock = last;
       break;
-    } else {
-      cursor = batch.at(-1)?._sequence;
     }
+    cursor = batch.at(-1)?._sequence;
     iterations = iterations + 1;
   } while (batch.length > 0 && iterations < maxIterations);
   return mostRecentBlock;
@@ -1550,7 +1602,7 @@ async function hydratedBlockByNumber(context, blockNumber) {
     if (blockNumber < 0) throw new Error(`Block number ${blockNumber} is less than 0`);
     if (blockNumber > Number.MAX_SAFE_INTEGER) throw new Error(`Block number ${blockNumber} is greater than the maximum safe integer`);
     if (blockNumber % 1 !== 0) throw new Error(`Block number ${blockNumber} is not an integer`);
-    const cacheKey = `${blockNumber}`;
+    const cacheKey = String(blockNumber);
     return await withContextCacheResponse(context, "hydratedBlockByNumber", cacheKey, async () => {
       const block = assertEx13(
         await blockFromBlockNumber(context, blockNumber),
@@ -1597,10 +1649,11 @@ var BaseConfigZod = z18.object({
   dataLake: z18.optional(DataLakeConfigZod).check(z18.describe("Configuration for data lakes")),
   evm: z18._default(EvmConfigZod, EvmConfigZod.parse({})).check(z18.describe("Configuration for EVM-backed services")),
   log: z18._default(LogConfigZod, LogConfigZod.parse({})).check(z18.describe("Configuration for logging")),
-  providerBindings: z18._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z18.describe("Per-moniker provider implementation and transport bindings")),
+  connections: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  providerBindings: z18._default(ProviderBindingsConfigZod, ProviderBindingsConfigZod.parse({})).check(z18.describe("Per-moniker provider connection bindings")),
   providers: z18._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z18.describe("Configuration for providers")),
   remote: z18._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z18.describe("Configuration for remote services")),
-  transports: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Named connection profiles (rpc, rest, s3, lmdb, mongo, evm-rpc)")),
+  transports: z18._default(TransportsConfigZod, TransportsConfigZod.parse({})).check(z18.describe("Deprecated alias for connections (kept in sync during migration)")),
   storage: z18._default(StorageConfigZod, StorageConfigZod.parse({})).check(z18.describe("Configuration for the storage")),
   telemetry: z18._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z18.describe("Configuration for telemetry")),
   validation: z18._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z18.describe("Configuration for validation"))
@@ -1859,7 +1912,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByStep(stepLevel, stepIndex) {
     return await this.spanAsync("blocksByStep", async () => {
-      assertEx15(Number.isInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
+      assertEx15(Number.isSafeInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
       const size = stepSize2(stepLevel);
       assertEx15(
         stepLevel <= blocksMaxStep,
@@ -1883,7 +1936,12 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async chainId(blockNumber = "latest") {
     return await this.spanAsync("chainId", async () => {
-      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx15(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
+      if (blockNumber === "latest") {
+        const headBlock = await this.finalizationViewer.headBlock();
+        return headBlock.chain;
+      }
+      const block = assertEx15(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`);
+      return block[0].chain;
     }, this.context);
   }
   async createHandler() {
@@ -1932,9 +1990,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     };
   }
   async getChainContextRead() {
+    const headBlock = await this.finalizationViewer.head();
     return {
       ...this.getBlockContextRead(),
-      head: (await this.finalizationViewer.head())[0]
+      head: headBlock[0]
     };
   }
   async startHandler() {
@@ -1981,10 +2040,11 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     }, this.headPollIntervalMs);
   }
   stopHeadPolling() {
-    if (this._headPollTimer) {
-      clearInterval(this._headPollTimer);
-      this._headPollTimer = null;
+    if (!this._headPollTimer) {
+      return;
     }
+    clearInterval(this._headPollTimer);
+    this._headPollTimer = null;
   }
 };
 __publicField(SimpleBlockViewer, "defaultMoniker", BlockViewerMoniker);
@@ -2007,7 +2067,7 @@ var SimpleChainContractViewer = class extends AbstractCreatableProvider {
     return this.finalizationViewer.chainId();
   }
   async chainIdAtBlockNumber(blockNumber) {
-    return await withContextCacheResponse(this.context, "chainIdAtBlockNumber", `${blockNumber}`, async () => {
+    return await withContextCacheResponse(this.context, "chainIdAtBlockNumber", String(blockNumber), async () => {
       let chainId = this.chainId();
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
@@ -2090,7 +2150,8 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._chainId = assertEx17(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => "chain.id is required if empty archivist");
+    const mostRecentBlock = await findMostRecentBlock(this.params.finalizedArchivist);
+    this._chainId = assertEx17(this.config.chain.id ?? mostRecentBlock?.chain, () => "chain.id is required if empty archivist");
     this._store = { chainMap: this.params.finalizedArchivist };
   }
   async head() {
@@ -2105,13 +2166,16 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     }, this.context);
   }
   async headBlock() {
-    return (await this.head())[0];
+    const headBlock = await this.head();
+    return headBlock[0];
   }
   async headHash() {
-    return (await this.headBlock())._hash;
+    const headBlock = await this.headBlock();
+    return headBlock._hash;
   }
   async headNumber() {
-    return (await this.headBlock()).block;
+    const headBlock = await this.headBlock();
+    return headBlock.block;
   }
   getBlockContextRead() {
     return {
@@ -2120,9 +2184,10 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     };
   }
   async getChainContextRead() {
+    const headBlock = await this.head();
     return {
       ...this.getBlockContextRead(),
-      head: (await this.head())[0]
+      head: headBlock[0]
     };
   }
   async getCurrentHead() {