@xyo-network/xl1-protocol-sdk 2.0.10 → 2.0.12

package/dist/neutral/index.mjs

@@ -674,7 +674,7 @@ var tryHydrateBlock = async (archivist, hash, maxDepth = 1) => {
 // src/block/primitives/blockFromBlockNumber.ts
 import {
   asHash,
-  isDefined as isDefined4,
+  isDefined as isDefined3,
   spanAsync
 } from "@xylabs/sdk-js";
 import { toSafeJsonString } from "@xylabs/sdk-js";
@@ -686,91 +686,12 @@ import {
 
 // src/ChainContextHelpers.ts
 import {
-  isDefined as isDefined3,
+  isDefined as isDefined2,
   isObject,
   isUndefined as isUndefined4,
   timeBudget
 } from "@xylabs/sdk-js";
-
-// src/driver/cache/LruCacheMap.ts
-import { LRUCache as LRUCache2 } from "lru-cache";
-var LruCacheMap = class {
-  lruCache;
-  constructor(options) {
-    this.lruCache = new LRUCache2(options ?? { max: 5e3 });
-  }
-  clear() {
-    this.lruCache.clear();
-  }
-  delete(id) {
-    return this.lruCache.delete(id);
-  }
-  get(id) {
-    return this.lruCache.get(id);
-  }
-  getMany(id) {
-    const results = [];
-    for (const key of id) {
-      const value = this.lruCache.get(key);
-      if (value !== void 0) {
-        results.push(value);
-      }
-    }
-    return results;
-  }
-  has(id) {
-    return this.lruCache.has(id);
-  }
-  set(id, data) {
-    this.lruCache.set(id, data);
-  }
-  setMany(entries) {
-    for (const [key, value] of entries) {
-      this.lruCache.set(key, value);
-    }
-  }
-};
-
-// src/driver/memory/MemoryMap.ts
-import { isDefined as isDefined2 } from "@xylabs/sdk-js";
-var MemoryMap = class {
-  map;
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-  }
-  clear() {
-    this.map.clear();
-  }
-  delete(id) {
-    return this.map.delete(id);
-  }
-  get(id) {
-    return this.map.get(id);
-  }
-  getMany(ids) {
-    const results = [];
-    for (const id of ids) {
-      const data = this.map.get(id);
-      if (isDefined2(data)) {
-        results.push(data);
-      }
-    }
-    return results;
-  }
-  has(id) {
-    return this.map.has(id);
-  }
-  set(id, data) {
-    this.map.set(id, data);
-  }
-  setMany(entries) {
-    for (const [key, value] of entries) {
-      this.map.set(key, value);
-    }
-  }
-};
-
-// src/ChainContextHelpers.ts
+import { LruCacheMap, MemoryMap } from "@xyo-network/xl1-driver-memory";
 function contextCache(context, name, create) {
   if (!isObject(context.caches)) {
     throw new Error("Context does not have an appropriate caches property");
@@ -788,7 +709,7 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4 }
   );
   const { timeBudgetLimit = 0 } = context;
   const cacheResult = await cache.get(key);
-  if (isDefined3(cacheResult)) {
+  if (isDefined2(cacheResult)) {
     return cacheResult;
   }
   const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func();
@@ -803,7 +724,7 @@ async function blockFromBlockNumber(context, blockNumber) {
     const { chainMap, head } = context;
     return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
       const [result] = await chainMap.get([head._hash]);
-      if (!isDefined4(result)) {
+      if (!isDefined3(result)) {
         throw new Error(`Head block not found for hash: ${head._hash}`);
       }
       let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
@@ -816,8 +737,8 @@ async function blockFromBlockNumber(context, blockNumber) {
       while (currentBlock.block > blockNumber) {
         let jumpHash = currentBlock.previous;
         let jumpBlockNumber = currentBlock.block - 1;
-        for (const [step, stepSize2] of StepSizes.entries()) {
-          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize2 - 1;
+        for (const [step, stepSize4] of StepSizes.entries()) {
+          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize4 - 1;
           if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
             jumpBlockNumber = possibleJumpBlockNumber;
             jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`);
@@ -826,7 +747,7 @@ async function blockFromBlockNumber(context, blockNumber) {
         const [newBlock] = await chainMap.get([
           asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
         ]);
-        if (!isDefined4(newBlock)) {
+        if (!isDefined3(newBlock)) {
           throw new Error(`Block not found for jump hash: ${jumpHash}`);
         }
         currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
@@ -1241,10 +1162,10 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry12, z as z17 } from "zod/mini";
+import { globalRegistry as globalRegistry13, z as z18 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z16 } from "zod/mini";
+import { z as z17 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
@@ -1414,11 +1335,11 @@ var RpcRemoteConfigZod = z11.union([HttpRpcRemoteConfigZod, PostMessageRpcRemote
 var RemoteConfigZod = z11.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined as isDefined5, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
+import { isDefined as isDefined4, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry8, z as z12 } from "zod";
 var hasMongoConfig = (config) => {
   if (isUndefined5(config)) return false;
-  return isDefined5(config.connectionString) && isDefined5(config.database) && isDefined5(config.domain);
+  return isDefined4(config.connectionString) && isDefined4(config.database) && isDefined4(config.domain);
 };
 var MongoConfigZod = z12.object({
   // TODO: Create from other arguments
@@ -1449,11 +1370,47 @@ var MongoConfigZod = z12.object({
   })
 });
 
-// src/config/storage/Storage.ts
+// 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 StorageConfigZod = z13.object({
+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"
+  }),
+  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/Storage.ts
+import { globalRegistry as globalRegistry10, z as z14 } from "zod";
+var StorageConfigZod = z14.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z13.string().optional().register(globalRegistry9, {
+  r2: R2ConfigZod.optional().describe("Configuration for the Cloudflare R2 storage driver"),
+  root: z14.string().optional().register(globalRegistry10, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -1461,7 +1418,7 @@ var StorageConfigZod = z13.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry10, z as z14 } from "zod";
+import { globalRegistry as globalRegistry11, z as z15 } from "zod";
 var DefaultMetricsScrapePorts = {
   api: 9465,
   bridge: 9468,
@@ -1469,29 +1426,29 @@ var DefaultMetricsScrapePorts = {
   producer: 9464,
   rewardRedemptionApi: 9467
 };
-var MetricsScrapeConfigZod = z14.object({
-  path: z14.string().default("/metrics").register(globalRegistry10, {
+var MetricsScrapeConfigZod = z15.object({
+  path: z15.string().default("/metrics").register(globalRegistry11, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z14.coerce.number().int().positive().optional().register(globalRegistry10, {
+  port: z15.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 = z14.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z14.object({
+var MetricsConfigZod = z15.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z15.object({
   // OpenTelemetry options
-  otlpEndpoint: z14.url().optional().register(globalRegistry10, {
+  otlpEndpoint: z15.url().optional().register(globalRegistry11, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z14.object({
+var TelemetryConfigZod = z15.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -1500,20 +1457,20 @@ var TelemetryConfigZod = z14.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/address";
-import { globalRegistry as globalRegistry11, z as z15 } from "zod";
+import { globalRegistry as globalRegistry12, z as z16 } from "zod";
 
 // src/primitives/block/range/blockRangeSteps.ts
 import { asXL1BlockNumber as asXL1BlockNumber2, StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
 function blockRangeSteps(range, steps) {
   const result = [];
   for (const step of steps) {
-    const stepSize2 = StepSizes3[step];
-    const startOfFirstStepCandidate = range[0] - range[0] % stepSize2 + stepSize2;
+    const stepSize4 = StepSizes3[step];
+    const startOfFirstStepCandidate = range[0] - range[0] % stepSize4 + stepSize4;
     const startOfFirstStep = asXL1BlockNumber2(
       startOfFirstStepCandidate,
       { name: "blockRangeSteps" }
     );
-    for (let block = startOfFirstStep; block <= range[1]; block = asXL1BlockNumber2(block + stepSize2, { name: "blockRangeSteps" })) {
+    for (let block = startOfFirstStep; block <= range[1]; block = asXL1BlockNumber2(block + stepSize4, { name: "blockRangeSteps" })) {
       result.push({ step, block });
     }
   }
@@ -1771,9 +1728,9 @@ function mergeTransfers(transfers) {
 // src/primitives/step/stepBlockRange.ts
 import { asXL1BlockRange as asXL1BlockRange4, StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol-lib";
 function stepBlockRange({ block, step }) {
-  const stepSize2 = StepSizes5[step];
-  const start = block - stepSize2;
-  return asXL1BlockRange4([start, start + stepSize2 - 1], { name: "stepBlockRange" });
+  const stepSize4 = StepSizes5[step];
+  const start = block - stepSize4;
+  return asXL1BlockRange4([start, start + stepSize4 - 1], { name: "stepBlockRange" });
 }
 
 // src/primitives/step/stepTransferIndex.ts
@@ -1783,9 +1740,9 @@ function stepTransferIndex(block, step) {
   let rewardTransferCount = 0;
   let rewardTransferIndex = -1;
   for (let i = 3; i < StepSizes6.length; i++) {
-    const stepSize2 = StepSizes6[i];
-    if (block % stepSize2 === 0) {
-      if (stepSize2 === StepSizes6[step]) {
+    const stepSize4 = StepSizes6[i];
+    if (block % stepSize4 === 0) {
+      if (stepSize4 === StepSizes6[step]) {
         rewardTransferIndex = rewardTransferCount;
       }
       rewardTransferCount++;
@@ -2134,7 +2091,7 @@ async function activeStakeAtTimeByAddress(chain, staked, time, staker) {
 }
 
 // src/primitives/stake/activeStakeAtTimeByPosition.ts
-import { isUndefined as isUndefined6 } from "@xylabs/sdk-js";
+import { isUndefined as isUndefined7 } from "@xylabs/sdk-js";
 
 // src/primitives/stake/mergedAddRemoveStakeEventsByPosition.ts
 async function mergedAddRemoveStakeEventsByPosition(chainEvents, range, position) {
@@ -2152,7 +2109,7 @@ async function activeStakeAtTimeByPosition(chainStakeEvents, externalTime, posit
   let result = 0n;
   for (const event of stakeEvents) {
     if (event.time > externalTime) break;
-    if (isUndefined6(position) || position === Number(event.args.id)) {
+    if (isUndefined7(position) || position === Number(event.args.id)) {
       if (event.name === "StakeAdded") {
         result += event.args.amount;
       } else if (event.name === "StakeRemoved") {
@@ -2384,11 +2341,11 @@ function toValidUncle(_context, finalizedWindowedChain, possibleUncle) {
   }
   const allUncleTransactions = prunedPossibleUncle.flatMap((b) => b[1]).filter(isTransactionBoundWitness2);
   const allFinalizedTransactions = finalizedWindowedChain.flatMap((b) => b[1]).filter(isTransactionBoundWitness2);
-  const txPossiblyBeforeWindow = allUncleTransactions.find((tx) => tx.nbf < finalizedWindowStartBlockNumber);
+  const txPossiblyBeforeWindow = allUncleTransactions.some((tx) => tx.nbf < finalizedWindowStartBlockNumber);
   if (txPossiblyBeforeWindow) {
     return;
   }
-  const txExistsInWindow = allUncleTransactions.find((tx) => allFinalizedTransactions.find((finalTx) => finalTx._hash === tx._hash));
+  const txExistsInWindow = allUncleTransactions.some((tx) => allFinalizedTransactions.some((finalTx) => finalTx._hash === tx._hash));
   if (txExistsInWindow) {
     return;
   }
@@ -2399,24 +2356,24 @@ function findUncles(context, finalizedWindowedChain, blocks) {
 }
 
 // src/config/Validation.ts
-var ValidationConfigZod = z15.object({
-  allowedRewardRedeemers: z15.array(XyoAddressZod2).optional().register(globalRegistry11, {
+var ValidationConfigZod = z16.object({
+  allowedRewardRedeemers: z16.array(XyoAddressZod2).optional().register(globalRegistry12, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z15.array(XyoAddressZod2).optional().register(globalRegistry11, {
+  allowedRewardEscrowAccountSigners: z16.array(XyoAddressZod2).optional().register(globalRegistry12, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z15.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry11, {
+  minCandidates: z16.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry12, {
     default: DEFAULT_MIN_CANDIDATES,
     description: "Minimum number of uncle candidates before selecting the best uncle",
     title: "validation.minCandidates",
     type: "number"
   }),
-  backoffMs: z15.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry11, {
+  backoffMs: z16.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry12, {
     default: DEFAULT_BACKOFF_MS,
     description: "Back-off timeout in ms. If head age exceeds this, minCandidates is ignored",
     title: "validation.backoffMs",
@@ -2425,26 +2382,26 @@ var ValidationConfigZod = z15.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z16.object({
-  chain: z16._default(ChainConfigZod, ChainConfigZod.parse({})).check(z16.describe("Configuration for the chain")),
-  dataLake: z16.optional(DataLakeConfigZod).check(z16.describe("Configuration for data lakes")),
-  evm: z16._default(EvmConfigZod, EvmConfigZod.parse({})).check(z16.describe("Configuration for EVM-backed services")),
-  log: z16._default(LogConfigZod, LogConfigZod.parse({})).check(z16.describe("Configuration for logging")),
-  providers: z16._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z16.describe("Configuration for providers")),
-  remote: z16._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z16.describe("Configuration for remote services")),
-  storage: z16._default(StorageConfigZod, StorageConfigZod.parse({})).check(z16.describe("Configuration for the storage")),
-  telemetry: z16._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z16.describe("Configuration for telemetry")),
-  validation: z16._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z16.describe("Configuration for validation"))
+var BaseConfigZod = 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"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z17.string().check(z17.regex(
+var AccountPathZod = z18.string().check(z18.regex(
   /^(m(\/\d+'?)+|\d+'?(\/\d+'?)*)$/,
   `Invalid BIP-32 derivation path. Use either an absolute path like "m/44'/60'/0'/0/0" or a relative path like "0", "0/1", or "44'/60'/0'/0/0".`
 ));
-var ActorConfigZod = z17.extend(BaseConfigZod, {
-  name: z17.string(),
-  accountPath: z17.optional(AccountPathZod).register(globalRegistry12, {
+var ActorConfigZod = z18.extend(BaseConfigZod, {
+  name: z18.string(),
+  accountPath: z18.optional(AccountPathZod).register(globalRegistry13, {
     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"
@@ -2455,22 +2412,22 @@ var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z18 } from "zod/mini";
-var ActorsConfigZod = z18._default(
-  z18.array(z18.looseObject(ActorConfigZod.shape)).check(z18.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+import { z as 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")),
   []
 );
 
 // src/config/Config.ts
-import { globalRegistry as globalRegistry13, z as z19 } from "zod/mini";
-var ConfigZod = z19.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry14, z as z20 } from "zod/mini";
+var ConfigZod = z20.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z19.optional(z19.coerce.number()).register(globalRegistry13, {
+  healthCheckPort: z20.optional(z20.coerce.number()).register(globalRegistry14, {
     description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
     title: "healthCheckPort",
     type: "number"
   })
-}).check(z19.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z20.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 function resolveConfig(config) {
   const parsedConfig = ConfigZod.parse(config);
   const {
@@ -2479,7 +2436,7 @@ function resolveConfig(config) {
     ...rootConfig
   } = parsedConfig;
   parsedConfig.actors = actors.map((actorConfig) => {
-    return z19.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
+    return z20.looseObject(ActorConfigZod.shape).parse({ ...rootConfig, ...actorConfig });
   });
   return parsedConfig;
 }
@@ -2490,15 +2447,15 @@ import {
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry14, z as z20 } from "zod/mini";
-var HostActorConfigZod = z20.extend(ActorConfigZod, {
-  host: z20._default(z20.string(), "localhost").register(globalRegistry14, {
+import { globalRegistry as globalRegistry15, z as z21 } from "zod/mini";
+var HostActorConfigZod = z21.extend(ActorConfigZod, {
+  host: z21._default(z21.string(), "localhost").register(globalRegistry15, {
     default: "localhost",
     description: "Host for the Actor",
     title: "host",
     type: "string"
   }),
-  port: z20._default(z20.coerce.number(), 8080).register(globalRegistry14, {
+  port: z21._default(z21.coerce.number(), 8080).register(globalRegistry15, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -2510,30 +2467,30 @@ var asHostActorConfig = zodAsFactory4(HostActorConfigZod, "asHostActorConfig");
 var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
 
 // src/config/UsageMeta.ts
-import { z as z21 } from "zod";
-var DescriptionSchema = z21.string();
-var TitleSchema = z21.string();
-var JSONSchemaMetaSchema = z21.object({
-  id: z21.string().optional(),
+import { z as z22 } from "zod";
+var DescriptionSchema = z22.string();
+var TitleSchema = z22.string();
+var JSONSchemaMetaSchema = z22.object({
+  id: z22.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z21.boolean().optional()
-}).catchall(z21.unknown());
+  deprecated: z22.boolean().optional()
+}).catchall(z22.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z21.array(z21.union([z21.string(), z21.number(), z21.literal(true), z21.undefined()])).readonly();
+var ChoicesSchema = z22.array(z22.union([z22.string(), z22.number(), z22.literal(true), z22.undefined()])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z21.unknown().optional(),
+  default: z22.unknown().optional(),
   description: DescriptionSchema,
-  group: z21.string().optional(),
-  hidden: z21.boolean().optional(),
+  group: z22.string().optional(),
+  hidden: z22.boolean().optional(),
   title: TitleSchema,
-  type: z21.union([
-    z21.literal("array"),
-    z21.literal("count"),
-    z21.literal("boolean"),
-    z21.literal("number"),
-    z21.literal("string")
+  type: z22.union([
+    z22.literal("array"),
+    z22.literal("count"),
+    z22.literal("boolean"),
+    z22.literal("number"),
+    z22.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -2546,7 +2503,7 @@ import {
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
-import { z as z23 } from "zod/mini";
+import { z as z24 } from "zod/mini";
 
 // src/model/CreatableProviderContext.zod.ts
 import {
@@ -2555,17 +2512,17 @@ import {
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z22 } from "zod/mini";
-var RuntimeStatusMonitorZod = z22.custom((val) => val && typeof val === "object");
-var ProviderFactoryLocatorZod = z22.lazy(() => z22.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
-var BaseConfigContextZod = z22.extend(CachingContextZod, {
-  config: z22.looseObject(BaseConfigZod.shape),
-  locator: z22.optional(ProviderFactoryLocatorZod)
+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)
 });
-var CreatableProviderContextZod = z22.lazy(() => z22.extend(BaseConfigContextZod, {
-  _id: z22.optional(z22.string()),
+var CreatableProviderContextZod = z23.lazy(() => z23.extend(BaseConfigContextZod, {
+  _id: z23.optional(z23.string()),
   locator: ProviderFactoryLocatorZod,
-  statusReporter: z22.optional(RuntimeStatusMonitorZod)
+  statusReporter: z23.optional(RuntimeStatusMonitorZod)
 }));
 var isBaseConfigContext = zodIsFactory4(BaseConfigContextZod);
 var asBaseConfigContext = zodAsFactory5(BaseConfigContextZod, "asBaseConfigContext");
@@ -3023,7 +2980,7 @@ var bundle2 = (root, transaction) => {
 };
 
 // src/context/Actor.ts
-var ActorConfigContext = z23.extend(BaseConfigContextZod, { config: ActorConfigZod });
+var ActorConfigContext = z24.extend(BaseConfigContextZod, { config: ActorConfigZod });
 var isActorConfigContext = zodIsFactory5(ActorConfigContext);
 var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
 var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
@@ -3413,8 +3370,8 @@ import {
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory6
 } from "@xylabs/sdk-js";
-import { z as z24 } from "zod/mini";
-var HostActorConfigContext = z24.extend(BaseConfigContextZod, { config: HostActorConfigZod });
+import { z as z25 } from "zod/mini";
+var HostActorConfigContext = z25.extend(BaseConfigContextZod, { config: HostActorConfigZod });
 var isHostActorConfigContext = zodIsFactory6(HostActorConfigContext);
 var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActorConfigContext");
 var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
@@ -3455,26 +3412,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/eip-712/Types.ts
-import { z as z25 } from "zod";
-var TypedDataDomainZod = z25.object({
-  name: z25.string().nullable().optional(),
-  version: z25.string().nullable().optional(),
-  chainId: z25.union([z25.string(), z25.number(), z25.bigint()]).nullable().optional(),
-  verifyingContract: z25.string().nullable().optional(),
-  salt: z25.union([z25.string(), z25.instanceof(Uint8Array)]).nullable().optional()
+import { z as z26 } from "zod";
+var TypedDataDomainZod = z26.object({
+  name: z26.string().nullable().optional(),
+  version: z26.string().nullable().optional(),
+  chainId: z26.union([z26.string(), z26.number(), z26.bigint()]).nullable().optional(),
+  verifyingContract: z26.string().nullable().optional(),
+  salt: z26.union([z26.string(), z26.instanceof(Uint8Array)]).nullable().optional()
 });
-var TypedDataFieldZod = z25.object({
-  name: z25.string(),
-  type: z25.string()
+var TypedDataFieldZod = z26.object({
+  name: z26.string(),
+  type: z26.string()
 });
-var TypedDataTypesZod = z25.record(z25.string(), z25.array(TypedDataFieldZod));
-var TypedDataValueZod = z25.record(z25.string(), z25.any());
+var TypedDataTypesZod = z26.record(z26.string(), z26.array(TypedDataFieldZod));
+var TypedDataValueZod = z26.record(z26.string(), z26.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z26.object({
+var EIP712DataPayloadFieldsZod = z27.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -3492,11 +3449,11 @@ import {
   asSchema as asSchema3,
   isPayloadOfZodType as isPayloadOfZodType2
 } from "@xyo-network/sdk-js";
-import { z as z27 } from "zod";
-var EIP712SignaturePayloadFieldsZod = z27.object({
-  address: z27.string(),
+import { z as z28 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z28.object({
+  address: z28.string(),
   hash: HashZod,
-  signature: z27.string()
+  signature: z28.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -3525,7 +3482,7 @@ var signEIP712Message = async (signer, data) => {
 };
 
 // src/eip-712/verify.ts
-import { asHash as asHash3, isUndefined as isUndefined7 } from "@xylabs/sdk-js";
+import { asHash as asHash3, isUndefined as isUndefined8 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
 import { verifyTypedData } from "ethers";
 var verifyEIP712Message = async (data, sig) => {
@@ -3536,7 +3493,7 @@ var verifyEIP712Message = async (data, sig) => {
   } = sig;
   const { schema, ...fields } = data;
   const signedHash = asHash3(hash);
-  if (isUndefined7(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
+  if (isUndefined8(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 };
@@ -3605,7 +3562,7 @@ var toPositiveBigInt = (value) => {
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
 import {
   asHash as asHash4,
-  assertEx as assertEx32,
+  assertEx as assertEx33,
   exists as exists3,
   isDefined as isDefined17,
   ZERO_ADDRESS
@@ -3613,13 +3570,13 @@ import {
 import {
   AccountBalanceViewerMoniker,
   asRange,
-  asXL1BlockNumber as asXL1BlockNumber7,
+  asXL1BlockNumber as asXL1BlockNumber8,
   asXL1BlockRange as asXL1BlockRange10,
   AttoXL1 as AttoXL13,
   BlockViewerMoniker,
   isChainQualifiedHeadConfig as isChainQualifiedHeadConfig4,
   isChainQualifiedRangeConfig as isChainQualifiedRangeConfig4,
-  StepSizes as StepSizes12,
+  StepSizes as StepSizes13,
   TransferSchema as TransferSchema2
 } from "@xyo-network/xl1-protocol-lib";
 import { Semaphore } from "async-mutex";
@@ -3639,41 +3596,56 @@ var isBalancesStepSummaryWithStorageMeta = (value) => {
 };
 var asBalancesStepSummaryWithStorageMeta = AsObjectFactory5.create(isBalancesStepSummaryWithStorageMeta);
 
-// src/summary/model/SchemasStepSummary.ts
+// src/summary/model/BlocksStepSummary.ts
 import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/sdk-js";
 import {
   asSchema as asSchema6,
   isPayloadOfSchemaType as isPayloadOfSchemaType4,
   isStorageMeta as isStorageMeta3
 } from "@xyo-network/sdk-js";
-var SchemasStepSummarySchema = asSchema6("network.xyo.step.summary.schemas", true);
-var isSchemasStepSummary = isPayloadOfSchemaType4(SchemasStepSummarySchema);
-var asSchemasStepSummary = AsObjectFactory6.create(isSchemasStepSummary);
+var BlocksStepSummarySchema = asSchema6("network.xyo.step.summary.blocks", true);
+var isBlocksStepSummary = isPayloadOfSchemaType4(BlocksStepSummarySchema);
+var asBlocksStepSummary = AsObjectFactory6.create(isBlocksStepSummary);
+var isBlocksStepSummaryWithStorageMeta = (value) => {
+  return isBlocksStepSummary(value) && isStorageMeta3(value);
+};
+var asBlocksStepSummaryWithStorageMeta = AsObjectFactory6.create(isBlocksStepSummaryWithStorageMeta);
+
+// src/summary/model/SchemasStepSummary.ts
+import { AsObjectFactory as AsObjectFactory7 } from "@xylabs/sdk-js";
+import {
+  asSchema as asSchema7,
+  isPayloadOfSchemaType as isPayloadOfSchemaType5,
+  isStorageMeta as isStorageMeta4
+} from "@xyo-network/sdk-js";
+var SchemasStepSummarySchema = asSchema7("network.xyo.step.summary.schemas", true);
+var isSchemasStepSummary = isPayloadOfSchemaType5(SchemasStepSummarySchema);
+var asSchemasStepSummary = AsObjectFactory7.create(isSchemasStepSummary);
 var isSchemasStepSummaryWithStorageMeta = (value) => {
-  return isSchemasStepSummary(value) && isStorageMeta3(value);
+  return isSchemasStepSummary(value) && isStorageMeta4(value);
 };
-var asSchemasStepSummaryWithStorageMeta = AsObjectFactory6.create(isSchemasStepSummaryWithStorageMeta);
+var asSchemasStepSummaryWithStorageMeta = AsObjectFactory7.create(isSchemasStepSummaryWithStorageMeta);
 
 // src/summary/model/StepSummary.ts
 import {
-  asSchema as asSchema7
+  asSchema as asSchema8
 } from "@xyo-network/sdk-js";
-var StepSummarySchema = asSchema7("network.xyo.step.summary", true);
+var StepSummarySchema = asSchema8("network.xyo.step.summary", true);
 
 // src/summary/model/TransfersSummary.ts
-import { AsObjectFactory as AsObjectFactory7 } from "@xylabs/sdk-js";
+import { AsObjectFactory as AsObjectFactory8 } from "@xylabs/sdk-js";
 import {
-  asSchema as asSchema8,
-  isPayloadOfSchemaType as isPayloadOfSchemaType5,
-  isStorageMeta as isStorageMeta4
+  asSchema as asSchema9,
+  isPayloadOfSchemaType as isPayloadOfSchemaType6,
+  isStorageMeta as isStorageMeta5
 } from "@xyo-network/sdk-js";
-var TransfersStepSummarySchema = asSchema8("network.xyo.step.summary.transfer", true);
-var isTransfersStepSummary = isPayloadOfSchemaType5(TransfersStepSummarySchema);
-var asTransfersStepSummary = AsObjectFactory7.create(isTransfersStepSummary);
+var TransfersStepSummarySchema = asSchema9("network.xyo.step.summary.transfer", true);
+var isTransfersStepSummary = isPayloadOfSchemaType6(TransfersStepSummarySchema);
+var asTransfersStepSummary = AsObjectFactory8.create(isTransfersStepSummary);
 var isTransfersStepSummaryWithStorageMeta = (value) => {
-  return isTransfersStepSummary(value) && isStorageMeta4(value);
+  return isTransfersStepSummary(value) && isStorageMeta5(value);
 };
-var asTransfersStepSummaryWithStorageMeta = AsObjectFactory7.create(isTransfersStepSummaryWithStorageMeta);
+var asTransfersStepSummaryWithStorageMeta = AsObjectFactory8.create(isTransfersStepSummaryWithStorageMeta);
 
 // src/summary/primitives/balances/balancesMaxStep.ts
 var balancesMaxStep = 5;
@@ -3777,25 +3749,89 @@ async function balancesSummary(context, semaphores, blockViewer, summaryMap, con
   }, { ...context, timeBudgetLimit: 500 });
 }
 
+// src/summary/primitives/blocks/blocksMaxStep.ts
+var blocksMaxStep = 3;
+
+// src/summary/primitives/blocks/blocksStepSummaryFromRange.ts
+import { assertEx as assertEx28, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
+import { isAnyPayload as isAnyPayload4 } from "@xyo-network/sdk-js";
+import { asXL1BlockNumber as asXL1BlockNumber6, StepSizes as StepSizes9 } from "@xyo-network/xl1-protocol-lib";
+function blocksStepSummaryKey(frameHeadHash, frameSize) {
+  return `${frameHeadHash}|${frameSize}`;
+}
+async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
+  const cacheKey = `${range[0]}|${range[1]}`;
+  return await withContextCacheResponse(context, "blocksStepSummaryFromRange", cacheKey, async () => {
+    return await spanRootAsync4("blocksStepSummaryFromRange", async () => {
+      const frameHead = assertEx28(
+        await blockViewer.blockByNumber(range[1]),
+        () => `Block not found for number: ${range[1]}`
+      );
+      const frameHeadHash = frameHead[0]._hash;
+      const frameSize = range[1] - range[0] + 1;
+      let result;
+      if (frameSize === 1) {
+        result = {
+          schema: BlocksStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: -1,
+          blocks: [frameHead]
+        };
+      } else {
+        const step = StepSizes9.indexOf(asXL1BlockNumber6(frameSize, true));
+        assertEx28(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
+        const key = blocksStepSummaryKey(frameHeadHash, frameSize);
+        const summaryResult = await summaryMap.get(key);
+        if (isAnyPayload4(summaryResult)) {
+          result = asBlocksStepSummary(summaryResult, { required: true });
+        } else {
+          await semaphores[step].acquire();
+          try {
+            const subRanges = deepCalculateFramesFromRange(range, step - 1);
+            const subResults = await Promise.all(subRanges.map((subRange) => blocksStepSummaryFromRange(
+              context,
+              semaphores,
+              blockViewer,
+              summaryMap,
+              subRange
+            )));
+            const blocks = subResults.flatMap((subResult) => subResult.blocks);
+            result = {
+              schema: BlocksStepSummarySchema,
+              hash: frameHeadHash,
+              stepSize: frameSize,
+              blocks
+            };
+            await summaryMap.set(key, result);
+          } finally {
+            semaphores[step].release();
+          }
+        }
+      }
+      return result;
+    }, { ...context, timeBudgetLimit: 500 });
+  }, { max: 1e5 });
+}
+
 // src/summary/primitives/schemas/schemasMaxStep.ts
-import { StepSizes as StepSizes9 } from "@xyo-network/xl1-protocol-lib";
-var schemasMaxStep = StepSizes9.length - 1;
+import { StepSizes as StepSizes10 } from "@xyo-network/xl1-protocol-lib";
+var schemasMaxStep = StepSizes10.length - 1;
 
 // src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
-import { assertEx as assertEx28 } from "@xylabs/sdk-js";
+import { assertEx as assertEx29 } from "@xylabs/sdk-js";
 import {
-  isAnyPayload as isAnyPayload4,
+  isAnyPayload as isAnyPayload5,
   isBoundWitness as isBoundWitness2,
   isHashMeta,
   PayloadBuilder as PayloadBuilder17
 } from "@xyo-network/sdk-js";
-import { StepSizes as StepSizes10 } from "@xyo-network/xl1-protocol-lib";
+import { StepSizes as StepSizes11 } from "@xyo-network/xl1-protocol-lib";
 async function schemasStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
-  const [frameHead] = assertEx28(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
+  const [frameHead] = assertEx29(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
   const frameSize = range[1] - range[0] + 1;
   let result;
   if (frameSize === 1) {
-    const [block, payloads] = assertEx28(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
+    const [block, payloads] = assertEx29(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
     const boundWitnesses = [block, ...payloads.filter((x) => isBoundWitness2(x) && isHashMeta(x))];
     const schemas = {};
     for (const bw of boundWitnesses) {
@@ -3811,10 +3847,10 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
       schemas
     });
   } else {
-    const step = StepSizes10.indexOf(frameSize);
-    assertEx28(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
+    const step = StepSizes11.indexOf(frameSize);
+    assertEx29(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes11.join(", ")}`);
     const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`);
-    if (isAnyPayload4(summaryResult)) {
+    if (isAnyPayload5(summaryResult)) {
       result = summaryResult;
     } else {
       await semaphores[step].acquire();
@@ -3851,7 +3887,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
 }
 
 // src/summary/primitives/schemas/schemasSummary.ts
-import { assertEx as assertEx29, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx30, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4,
   asXL1BlockRange as asXL1BlockRange8,
@@ -3859,9 +3895,9 @@ import {
   isChainQualifiedRangeConfig as isChainQualifiedRangeConfig2
 } from "@xyo-network/xl1-protocol-lib";
 async function schemasSummary(context, semaphores, blockViewer, summaryMap, config) {
-  return await spanRootAsync4("schemasSummary", async () => {
+  return await spanRootAsync5("schemasSummary", async () => {
     const headHash = isChainQualifiedHeadConfig2(config) ? config.head : await blockViewer.currentBlockHash();
-    const [head] = assertEx29(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
+    const [head] = assertEx30(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig2(config) ? config.range : asXL1BlockRange8([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange8(
@@ -3884,21 +3920,21 @@ async function schemasSummary(context, semaphores, blockViewer, summaryMap, conf
 var transfersMaxStep = 4;
 
 // src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx30, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload5 } from "@xyo-network/sdk-js";
-import { asXL1BlockNumber as asXL1BlockNumber6, StepSizes as StepSizes11 } from "@xyo-network/xl1-protocol-lib";
+import { assertEx as assertEx31, spanRootAsync as spanRootAsync6 } from "@xylabs/sdk-js";
+import { isAnyPayload as isAnyPayload6 } from "@xyo-network/sdk-js";
+import { asXL1BlockNumber as asXL1BlockNumber7, StepSizes as StepSizes12 } from "@xyo-network/xl1-protocol-lib";
 function transfersSummaryKey(frameHeadHash, frameSize) {
   return `${frameHeadHash}|${frameSize}`;
 }
 async function transfersStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
   const cacheKey = `${range[0]}|${range[1]}`;
   return await withContextCacheResponse(context, "transfersStepSummaryFromRange", cacheKey, async () => {
-    return await spanRootAsync5("transfersStepSummaryFromRange", async () => {
-      const [frameHead] = assertEx30(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
+    return await spanRootAsync6("transfersStepSummaryFromRange", async () => {
+      const [frameHead] = assertEx31(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`);
       const frameSize = range[1] - range[0] + 1;
       let result;
       if (frameSize === 1) {
-        const [, payloads] = assertEx30(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
+        const [, payloads] = assertEx31(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
         const transfers = {};
         for (const [from, toMap] of Object.entries(netTransfersForPayloads(context, payloads))) {
           transfers[from] = transfers[from] ?? {};
@@ -3913,11 +3949,11 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
           transfers
         };
       } else {
-        const step = StepSizes11.indexOf(asXL1BlockNumber6(frameSize, true));
-        assertEx30(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes11.join(", ")}`);
+        const step = StepSizes12.indexOf(asXL1BlockNumber7(frameSize, true));
+        assertEx31(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes12.join(", ")}`);
         const key = transfersSummaryKey(frameHead._hash, frameSize);
         const summaryResult = await summaryMap.get(key);
-        if (isAnyPayload5(summaryResult)) {
+        if (isAnyPayload6(summaryResult)) {
           result = asTransfersStepSummary(summaryResult, { required: true });
         } else {
           await semaphores[step].acquire();
@@ -3965,7 +4001,7 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
 }
 
 // src/summary/primitives/transfers/transfersSummary.ts
-import { assertEx as assertEx31, spanRootAsync as spanRootAsync6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx32, spanRootAsync as spanRootAsync7 } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress2 } from "@xyo-network/address";
 import {
   asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta5,
@@ -3974,9 +4010,9 @@ import {
   isChainQualifiedRangeConfig as isChainQualifiedRangeConfig3
 } from "@xyo-network/xl1-protocol-lib";
 async function transfersSummary(context, semaphores, blockViewer, summaryMap, config) {
-  return await spanRootAsync6("transferSummary", async () => {
+  return await spanRootAsync7("transferSummary", async () => {
     const headHash = isChainQualifiedHeadConfig3(config) ? config.head : await blockViewer.currentBlockHash();
-    const [head] = assertEx31(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
+    const [head] = assertEx32(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta5(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig3(config) ? config.range : asXL1BlockRange9([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange9(
@@ -4002,9 +4038,9 @@ async function transfersSummary(context, semaphores, blockViewer, summaryMap, co
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
 var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
   moniker = SimpleAccountBalanceViewer.defaultMoniker;
-  _balanceStepSemaphores = StepSizes12.map(() => new Semaphore(20));
+  _balanceStepSemaphores = StepSizes13.map(() => new Semaphore(20));
   _blockViewer;
-  _transferStepSemaphores = StepSizes12.map(() => new Semaphore(20));
+  _transferStepSemaphores = StepSizes13.map(() => new Semaphore(20));
   get balancesSummaryMap() {
     return this.params.balancesSummaryMap;
   }
@@ -4017,8 +4053,8 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params = {}) {
     return {
       ...await super.paramsHandler(params),
-      balancesSummaryMap: assertEx32(params.balancesSummaryMap, () => "balancesSummaryMap is required"),
-      transfersSummaryMap: assertEx32(params.transfersSummaryMap, () => "transfersSummaryMap is required")
+      balancesSummaryMap: assertEx33(params.balancesSummaryMap, () => "balancesSummaryMap is required"),
+      transfersSummaryMap: assertEx33(params.transfersSummaryMap, () => "transfersSummaryMap is required")
     };
   }
   async accountBalance(address, config) {
@@ -4039,7 +4075,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
         const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
         const transfers = transferIndexes.map((index) => {
           const hash = block[0].payload_hashes[index];
-          return assertEx32(
+          return assertEx33(
             block[1].find((p) => p._hash === hash),
             () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`
           );
@@ -4072,7 +4108,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
       const head = isChainQualifiedHeadConfig4(config) ? config.head : await this.blockViewer.currentBlockHash();
       const range = isChainQualifiedRangeConfig4(config) ? config.range : asXL1BlockRange10([
         0,
-        assertEx32(
+        assertEx33(
           await this.blockViewer.blockByHash(head),
           () => `Error: Could not find block with hash ${head}`
         )[0].block
@@ -4087,11 +4123,11 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
       const qualifiedRange = qualifiedEntries[0][1][1].range;
       const qualifiedHeadHash = qualifiedEntries[0][1][1].head;
       for (const [_, [__, { range: range2, head: head2 }]] of qualifiedEntries) {
-        assertEx32(
+        assertEx33(
           range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1],
           () => "Inconsistent ranges in qualifiedAccountBalanceHistories"
         );
-        assertEx32(
+        assertEx33(
           head2 === qualifiedHeadHash,
           () => "Inconsistent head hashes in qualifiedAccountBalanceHistories"
         );
@@ -4125,8 +4161,8 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
   }
   async distillTransferHistory(address, range, max = 50) {
     return await this.spanAsync("distillTransferHistory", async () => {
-      if (range[1] - range[0] <= StepSizes12[0] || max <= 1) {
-        return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber7(n, true));
+      if (range[1] - range[0] <= StepSizes13[0] || max <= 1) {
+        return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber8(n, true));
       }
       const frames = deepCalculateFramesFromRange(asXL1BlockRange10(range, true), transfersMaxStep);
       const transferSummaryPairs = await Promise.all(frames.map(
@@ -4140,7 +4176,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
       });
       const resultBlockNumbers = /* @__PURE__ */ new Set();
       for (const [frame] of sortedTransferSummaryPairs) {
-        if (frame[1] - frame[0] + 1 > StepSizes12[0]) {
+        if (frame[1] - frame[0] + 1 > StepSizes13[0]) {
           const values = await this.distillTransferHistory(address, asXL1BlockRange10([frame[0], frame[1] - 1], true), max - resultBlockNumbers.size);
           for (const value of values) {
             resultBlockNumbers.add(value);
@@ -4162,7 +4198,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
     return await this.spanAsync("qualifiedAccountBalanceHistory", async () => {
       const range = asRange(headOrRange);
       const headHash = asHash4(headOrRange);
-      const [head] = assertEx32(isDefined17(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+      const [head] = assertEx33(isDefined17(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
       const startingRange = asXL1BlockRange10(range ?? [0, head.block], true);
       const blockNumbers = await this.distillTransferHistory(address, startingRange);
       const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists3);
@@ -4171,7 +4207,7 @@ var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
         const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
         const transfers = transferIndexes.map((index) => {
           const hash = block[0].payload_hashes[index];
-          return assertEx32(
+          return assertEx33(
             block[1].find((p) => p._hash === hash),
             () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`
           );
@@ -4201,20 +4237,25 @@ SimpleAccountBalanceViewer = __decorateClass([
 
 // src/simple/block/SimpleBlockViewer.ts
 import {
-  assertEx as assertEx33,
+  assertEx as assertEx34,
   exists as exists4,
-  isUndefined as isUndefined8
+  isUndefined as isUndefined9
 } from "@xylabs/sdk-js";
+import { LruCacheMap as LruCacheMap2 } from "@xyo-network/xl1-driver-memory";
 import {
   asSignedHydratedBlockWithHashMeta,
   asSignedHydratedBlockWithStorageMeta,
-  asXL1BlockNumber as asXL1BlockNumber8,
+  asXL1BlockNumber as asXL1BlockNumber9,
+  asXL1BlockRange as asXL1BlockRange11,
   BlockViewerMoniker as BlockViewerMoniker2,
-  FinalizationViewerMoniker
+  FinalizationViewerMoniker,
+  stepSize as stepSize2,
+  StepSizes as StepSizes14
 } from "@xyo-network/xl1-protocol-lib";
+import { Semaphore as Semaphore2 } from "async-mutex";
 
 // src/utils/HydratedCache.ts
-import { LRUCache as LRUCache3 } from "lru-cache";
+import { LRUCache as LRUCache2 } from "lru-cache";
 var HydratedCache = class {
   cache;
   context;
@@ -4222,7 +4263,7 @@ var HydratedCache = class {
   constructor(context, hydrateFunction, maxCount = 2e3, ttl = Number.MAX_SAFE_INTEGER) {
     this.context = context;
     this.hydrateFunction = hydrateFunction;
-    this.cache = new LRUCache3({ max: maxCount, ttl });
+    this.cache = new LRUCache2({ max: maxCount, ttl });
   }
   async get(hash) {
     const existing = this.cache.get(hash);
@@ -4237,12 +4278,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z28.ZodError;
+  return error instanceof z29.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z28.prettifyError(error);
+  return z29.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -4251,8 +4292,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   moniker = SimpleBlockViewer.defaultMoniker;
   _store;
   finalizationViewer;
-  payloadCache = new LruCacheMap({ max: 1e4 });
-  signedHydratedBlockWithHashMetaCache = new LruCacheMap({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  payloadCache = new LruCacheMap2({ max: 1e4 });
+  signedHydratedBlockWithHashMetaCache = new LruCacheMap2({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  _blockStepSemaphores = StepSizes14.map(() => new Semaphore2(20));
+  _blocksSummaryMap;
   _headPollHash;
   _headPollInProgress = false;
   _headPollTimer = null;
@@ -4260,6 +4303,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   get finalizedArchivist() {
     return this.params.finalizedArchivist;
   }
+  get blocksSummaryMap() {
+    this._blocksSummaryMap ??= this.params.blocksSummaryMap ?? new LruCacheMap2({ max: 32 });
+    return this._blocksSummaryMap;
+  }
   get headPollIntervalMs() {
     return this.params.headPollIntervalMs;
   }
@@ -4278,11 +4325,12 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     const headPollIntervalMs = params.headPollIntervalMs;
     if (headPollIntervalMs !== void 0) {
-      assertEx33(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
+      assertEx34(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
     }
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx33(params.finalizedArchivist, () => "finalizedArchivist is required"),
+      blocksSummaryMap: params.blocksSummaryMap,
+      finalizedArchivist: assertEx34(params.finalizedArchivist, () => "finalizedArchivist is required"),
       headPollIntervalMs
     };
   }
@@ -4303,7 +4351,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   async blockByNumber(blockNumber) {
     return await this.spanAsync("blockByNumber", async () => {
       const chainContext = await this.getChainContextRead();
-      if (isUndefined8(chainContext.head)) {
+      if (isUndefined9(chainContext.head)) {
         return null;
       }
       return await this.blockByNumberWithContext(chainContext, blockNumber);
@@ -4311,8 +4359,8 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByHash(hash, limit = 50) {
     return await this.spanAsync("blocksByHash", async () => {
-      assertEx33(limit > 0, () => "limit must be greater than 0");
-      assertEx33(limit <= 100, () => "limit must be less than 100");
+      assertEx34(limit > 0, () => "limit must be greater than 0");
+      assertEx34(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -4326,10 +4374,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByNumber(blockNumber, limit = 50) {
     return await this.spanAsync("blocksByNumber", async () => {
-      assertEx33(limit > 0, () => "limit must be greater than 0");
-      assertEx33(limit <= 100, () => "limit must be less than 100");
+      assertEx34(limit > 0, () => "limit must be greater than 0");
+      assertEx34(limit <= 100, () => "limit must be less than 100");
       const chainContext = await this.getChainContextRead();
-      if (isUndefined8(chainContext.head)) {
+      if (isUndefined9(chainContext.head)) {
         return [];
       }
       const blocks = [];
@@ -4337,15 +4385,39 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
       while (current && blocks.length < limit) {
         blocks.push(current);
         if (current[0].block === 0) break;
-        const previousNumber = asXL1BlockNumber8(current[0].block - 1, true);
+        const previousNumber = asXL1BlockNumber9(current[0].block - 1, true);
         current = await this.blockByNumberWithContext(chainContext, previousNumber);
       }
       return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
     }, this.context);
   }
+  async blocksByStep(stepLevel, stepIndex) {
+    return await this.spanAsync("blocksByStep", async () => {
+      assertEx34(Number.isInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
+      const size = stepSize2(stepLevel);
+      assertEx34(
+        stepLevel <= blocksMaxStep,
+        () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
+      );
+      const chainContext = await this.getChainContextRead();
+      if (isUndefined9(chainContext.head)) {
+        return [];
+      }
+      const start = stepIndex * size;
+      const end = Math.min(start + size - 1, chainContext.head.block);
+      if (end < start) {
+        return [];
+      }
+      const range = asXL1BlockRange11([start, end], { name: "blocksByStep" });
+      const frames = deepCalculateFramesFromRange(range, blocksMaxStep);
+      const summaries = await Promise.all(frames.map((frame) => blocksStepSummaryFromRange(this.context, this._blockStepSemaphores, this, this.blocksSummaryMap, frame)));
+      const blocks = summaries.flatMap((summary) => summary.blocks);
+      return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true)).toReversed();
+    }, this.context);
+  }
   async chainId(blockNumber = "latest") {
     return await this.spanAsync("chainId", async () => {
-      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx33(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
+      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx34(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
     }, this.context);
   }
   async createHandler() {
@@ -4373,9 +4445,9 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     remainingHashes = remainingHashes.filter((h) => !cachedHashes.has(h));
     const finalizedPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
     const resultPayloads = [...cachedPayloads, ...finalizedPayloads.filter(exists4)];
-    resultPayloads.map((payload) => {
+    for (const payload of resultPayloads) {
       this.payloadCache.set(payload._hash, payload);
-    });
+    }
     return resultPayloads;
   }
   async rate(range, timeUnit) {
@@ -4474,11 +4546,11 @@ SimpleBlockRewardViewer = __decorateClass([
 ], SimpleBlockRewardViewer);
 
 // src/simple/blockValidation/SimpleBlockValidationViewer.ts
-import { assertEx as assertEx34 } from "@xylabs/sdk-js";
+import { assertEx as assertEx35 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2,
-  asXL1BlockRange as asXL1BlockRange11,
+  asXL1BlockRange as asXL1BlockRange12,
   BlockValidationViewerMoniker,
   BlockViewerMoniker as BlockViewerMoniker3,
   ChainContractViewerMoniker,
@@ -4527,7 +4599,7 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
       head: void 0
     };
     const blocksWithMeta = await Promise.all(blocks.map((b) => Promise.all([PayloadBuilder18.addHashMeta(b[0]), PayloadBuilder18.addHashMeta(b[1])])));
-    const head = isChainQualifiedHeadConfig5(config) ? assertEx34(
+    const head = isChainQualifiedHeadConfig5(config) ? assertEx35(
       (await this.blockViewer.blockByHash(config.head))?.[0],
       () => `Specified a head that is not in the chain [${config.head}]`
     ) : void 0;
@@ -4535,7 +4607,7 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
     const validateProtocol = value ? this.doValidateProtocol.bind(this) : void 0;
     const validateState = state ? this.doValidateState.bind(this) : void 0;
     const chainIdAtBlockNumber = (blockNumber) => this.chainContractViewer.chainIdAtBlockNumber(blockNumber);
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange11([0, headBlock.block], true) };
+    const qualification = { head: headBlock._hash, range: asXL1BlockRange12([0, headBlock.block], true) };
     const [protocolResults, stateResults] = await Promise.all([
       validateProtocol?.(blocksWithMeta, chainIdAtBlockNumber),
       validateState?.(blocksWithMeta, chainIdAtBlockNumber)
@@ -4608,7 +4680,7 @@ SimpleBlockValidationViewer = __decorateClass([
 ], SimpleBlockValidationViewer);
 
 // src/simple/chainContractViewer/SimpleChainContractViewer.ts
-import { assertEx as assertEx35 } from "@xylabs/sdk-js";
+import { assertEx as assertEx36 } from "@xylabs/sdk-js";
 import { ChainContractViewerMoniker as ChainContractViewerMoniker2, FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleChainContractViewer = class extends AbstractCreatableProvider {
   moniker = SimpleChainContractViewer.defaultMoniker;
@@ -4625,7 +4697,7 @@ var SimpleChainContractViewer = class extends AbstractCreatableProvider {
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
       while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx35(await contractViewer.forkedChainContractViewer());
+        contractViewer = assertEx36(await contractViewer.forkedChainContractViewer());
         forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
         chainId = await contractViewer.chainId();
       }
@@ -4678,17 +4750,17 @@ var SimpleXyoClient = class {
 };
 
 // src/simple/datalake/RestDataLakeRunner.ts
-import { assertEx as assertEx36, exists as exists6 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload7, PayloadZodLoose } from "@xyo-network/sdk-js";
+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 z29 } from "zod/mini";
+import { z as z30 } from "zod/mini";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { FetchClientError, FetchJsonClient } from "@xylabs/sdk-js";
 import {
   exists as exists5
 } from "@xylabs/sdk-js";
-import { asAnyPayload as asAnyPayload4, isAnyPayload as isAnyPayload6 } from "@xyo-network/sdk-js";
+import { asAnyPayload as asAnyPayload4, isAnyPayload as isAnyPayload7 } from "@xyo-network/sdk-js";
 var AbstractRestDataLake = class extends AbstractCreatableProvider {
   get allowedSchemas() {
     return this.params.allowedSchemas;
@@ -4719,7 +4791,7 @@ var AbstractRestDataLake = class extends AbstractCreatableProvider {
     }
   }
   isAllowed(value) {
-    if (isAnyPayload6(value)) {
+    if (isAnyPayload7(value)) {
       return this.isAllowedSchema(value.schema);
     }
     return false;
@@ -4746,15 +4818,15 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
   }
   async insert(items) {
     const allowedItems = items.map((item) => {
-      if (isAnyPayload7(item) && this.isAllowed(item)) {
-        assertEx36(typeof item === "object" && item !== null, () => "Data must be an object");
+      if (isAnyPayload8(item) && this.isAllowed(item)) {
+        assertEx37(typeof item === "object" && item !== null, () => "Data must be an object");
         return item;
       }
       return null;
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.client.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z29.array(PayloadZodLoose).parse(result.data);
+      return z30.array(PayloadZodLoose).parse(result.data);
     } else {
       return [];
     }
@@ -4781,11 +4853,11 @@ RestDataLakeViewer = __decorateClass([
 
 // src/simple/datalake/SimpleDataLakeRunner.ts
 import { exists as exists7 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload9, PayloadBuilder as PayloadBuilder19 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload10, PayloadBuilder as PayloadBuilder19 } from "@xyo-network/sdk-js";
 import { DataLakeRunnerMoniker as DataLakeRunnerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 
 // src/simple/datalake/AbstractSimpleDataLake.ts
-import { isAnyPayload as isAnyPayload8 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload9 } from "@xyo-network/sdk-js";
 var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
   get allowedSchemas() {
     return this.params.allowedSchemas;
@@ -4804,7 +4876,7 @@ var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
     throw new Error("Method not implemented.");
   }
   isAllowed(value) {
-    if (isAnyPayload8(value)) {
+    if (isAnyPayload9(value)) {
       return this.isAllowedSchema(value.schema);
     }
     return true;
@@ -4833,7 +4905,7 @@ var SimpleDataLakeRunner = class extends AbstractSimpleDataLake {
     }))).filter(exists7);
   }
   async insert(items) {
-    const payloads = items.filter(isAnyPayload9).filter((i) => this.isAllowed(i));
+    const payloads = items.filter(isAnyPayload10).filter((i) => this.isAllowed(i));
     const hashPairs = await PayloadBuilder19.hashPairs(payloads);
     for (const [payload, hash] of hashPairs) {
       await this.map.set(hash, payload);
@@ -4890,7 +4962,7 @@ SimpleFinalizationRunner = __decorateClass([
 ], SimpleFinalizationRunner);
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
-import { assertEx as assertEx37 } from "@xylabs/sdk-js";
+import { assertEx as assertEx38 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
   ChainContractViewerMoniker as ChainContractViewerMoniker3,
@@ -4919,7 +4991,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx37(params.finalizedArchivist, () => "finalizedArchivist is required")
+      finalizedArchivist: assertEx38(params.finalizedArchivist, () => "finalizedArchivist is required")
     };
   }
   chainId() {
@@ -4927,18 +4999,18 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._chainId = assertEx37(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => "chain.id is required if empty archivist");
+    this._chainId = assertEx38(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => "chain.id is required if empty archivist");
     this._store = { chainMap: this.params.finalizedArchivist };
   }
   async head() {
     return await this.spanAsync("head", async () => {
-      const currentHead = assertEx37(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      const currentHead = assertEx38(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
         this.logger?.error(`Could not find current block with hash ${currentHead._hash}`);
       }
-      return assertEx37(block, () => "Could not find current block");
+      return assertEx38(block, () => "Could not find current block");
     }, this.context);
   }
   async headBlock() {
@@ -4964,8 +5036,8 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async getCurrentHead() {
     const chainArchivist = this.finalizedArchivist;
-    const result = assertEx37(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
-    assertEx37(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
+    const result = assertEx38(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
+    assertEx38(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
     return result;
   }
 };
@@ -4995,13 +5067,13 @@ var SimpleXyoGateway = class _SimpleXyoGateway extends AbstractCreatableProvider
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
 import {
-  assertEx as assertEx38,
+  assertEx as assertEx39,
   BigIntToJsonZod,
   isDefined as isDefined18
 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/sdk-js";
 import {
-  asXL1BlockNumber as asXL1BlockNumber9,
+  asXL1BlockNumber as asXL1BlockNumber10,
   DataLakeRunnerMoniker as DataLakeRunnerMoniker3,
   isSignedHydratedTransaction,
   TransferSchema as TransferSchema3,
@@ -5028,7 +5100,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     return this._signer;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx38(this.connection.viewer, () => "No viewer available on connection");
+    const viewer = assertEx39(this.connection.viewer, () => "No viewer available on connection");
     const {
       nbf,
       exp,
@@ -5036,15 +5108,15 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
       fees
     } = options ?? {};
     const resolvedChainId = isDefined18(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber9(isDefined18(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber9(isDefined18(exp) ? exp : resolvedNbf + 10, true);
+    const resolvedNbf = asXL1BlockNumber10(isDefined18(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber10(isDefined18(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
     return await this.addTransactionToChain(tx, await PayloadBuilder20.addHashMeta(offChain));
   }
   async addTransactionToChain(tx, offChain = []) {
     const connection = this.connection;
     const signer = this.signer;
-    const runner = assertEx38(connection.runner, () => "No runner available on connection");
+    const runner = assertEx39(connection.runner, () => "No runner available on connection");
     let signedTx;
     if (isSignedHydratedTransaction(tx)) {
       const [bw, payloads] = tx;
@@ -5059,7 +5131,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
   }
   async confirmSubmittedTransaction(txHash, options) {
     return await confirmSubmittedTransaction(
-      assertEx38(this.connection.viewer, () => "Connection viewer is undefined"),
+      assertEx39(this.connection.viewer, () => "Connection viewer is undefined"),
       txHash,
       options
     );
@@ -5096,7 +5168,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
 
 // src/simple/mempool/SimpleMempoolRunner.ts
 import {
-  assertEx as assertEx39,
+  assertEx as assertEx40,
   exists as exists8
 } from "@xylabs/sdk-js";
 import { isPayloadBundle, PayloadBuilder as PayloadBuilder21 } from "@xyo-network/sdk-js";
@@ -5105,6 +5177,7 @@ import {
   ChainContractViewerMoniker as ChainContractViewerMoniker4,
   DeadLetterQueueRunnerMoniker,
   DEFAULT_MAX_EXP_AHEAD,
+  elevatedTransaction,
   FinalizationViewerMoniker as FinalizationViewerMoniker4,
   isSignedHydratedBlockWithHashMeta,
   isSignedHydratedTransactionWithHashMeta,
@@ -5171,8 +5244,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      pendingBlocksArchivist: assertEx39(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required"),
-      pendingTransactionsArchivist: assertEx39(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required")
+      pendingBlocksArchivist: assertEx40(params?.pendingBlocksArchivist, () => "pendingBlocksArchivist is required"),
+      pendingTransactionsArchivist: assertEx40(params?.pendingTransactionsArchivist, () => "pendingTransactionsArchivist is required")
     };
   }
   async createHandler() {
@@ -5210,7 +5283,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
           return b;
         }
       }).filter(exists8);
-      assertEx39(
+      assertEx40(
         remainingBlockMap.length === remainingBlocks.length,
         () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`
       );
@@ -5272,7 +5345,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
           return t;
         }
       }).filter(exists8);
-      assertEx39(
+      assertEx40(
         remainingTransactionMap.length === remainingTransactions.length,
         () => `remainingTransactionMap length should match remainingTransactions length [${remainingTransactionMap.length}/${remainingTransactions.length}]`
       );
@@ -5335,14 +5408,15 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         await PayloadBuilder21.addHashMeta(payloads)
       ])
     );
+    const elevatedTransactions = hashedTransactions.map((tx) => elevatedTransaction(tx));
     if (this.validateOnSubmit) {
       const validationResults = await Promise.all(
-        hashedTransactions.map(async (tx) => this.transactionValidationViewer.validateTransaction(tx, { value: true, state: true }))
+        elevatedTransactions.map(async (tx) => this.transactionValidationViewer.validateTransaction(tx, { value: true, state: true }))
       );
       const failures = [];
       for (const [i, result] of validationResults.entries()) {
         if (!isSignedHydratedTransactionWithHashMeta(result)) {
-          failures.push({ tx: hashedTransactions[i], errors: result });
+          failures.push({ tx: elevatedTransactions[i], errors: result });
         }
       }
       if (failures.length > 0) {
@@ -5351,7 +5425,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         throw new Error(`SimpleMempoolRunner: rejected ${failures.length} transaction(s) at admission: ${detail}`);
       }
     }
-    const bundles = hashedTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
+    const bundles = elevatedTransactions.map((tx) => hydratedTransactionToPayloadBundle(tx));
     const inserted = await this.pendingTransactionsArchivist.insert(bundles);
     await this.enforceCap();
     return inserted.map((p) => p._hash);
@@ -5738,7 +5812,7 @@ function deduplicateWithBundleBySigner(items) {
 }
 
 // src/simple/network/SimpleXyoNetwork.ts
-import { fetchJsonGet, isUndefined as isUndefined9 } from "@xylabs/sdk-js";
+import { fetchJsonGet, isUndefined as isUndefined10 } from "@xylabs/sdk-js";
 import { isNetworkStatus } from "@xyo-network/xl1-protocol-lib";
 
 // src/simple/network/lib/FailedNetworkStatusPayloads.ts
@@ -5786,7 +5860,7 @@ var SimpleXyoNetwork = class {
   }
   async status() {
     const statusNetwork = StatusNetworks[this._networkId];
-    if (isUndefined9(statusNetwork)) {
+    if (isUndefined10(statusNetwork)) {
       throw new Error(`Unknown status network ID: ${this._networkId}`);
     }
     return await this.makeRequest(statusNetwork.statusUrl);
@@ -5811,7 +5885,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx40 } from "@xylabs/sdk-js";
+import { assertEx as assertEx41 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   invoker;
   _store;
@@ -5820,7 +5894,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx40(this._store, () => "Store must be defined to get permissions");
+    return assertEx41(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -5873,7 +5947,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx41 } from "@xylabs/sdk-js";
+import { assertEx as assertEx42 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   _invoker;
   permissions = [];
@@ -5881,7 +5955,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx41(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx42(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -6047,7 +6121,7 @@ SimpleStakeEventsViewer = __decorateClass([
 ], SimpleStakeEventsViewer);
 
 // src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts
-import { assertEx as assertEx42 } from "@xylabs/sdk-js";
+import { assertEx as assertEx43 } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress3 } from "@xyo-network/address";
 import {
   StakeTotalsViewerMoniker,
@@ -6091,7 +6165,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._stakeViewer = assertEx42(
+    this._stakeViewer = assertEx43(
       await this.locateAndCreate(StakeViewerMoniker),
       () => "Failed to create StakeViewer"
     );
@@ -6145,14 +6219,14 @@ SimpleStakeTotalsViewer = __decorateClass([
 ], SimpleStakeTotalsViewer);
 
 // src/simple/StakeViewer/SimpleStakeViewer.ts
-import { assertEx as assertEx43, toAddress } from "@xylabs/sdk-js";
+import { assertEx as assertEx44, toAddress } from "@xylabs/sdk-js";
 import { asXyoAddress as asXyoAddress4 } from "@xyo-network/address";
 import { StakeEventsViewerMoniker as StakeEventsViewerMoniker2, StakeViewerMoniker as StakeViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleStakeViewer = class extends AbstractCreatableProvider {
   moniker = SimpleStakeViewer.defaultMoniker;
   _chainStakeEventsViewer;
   get stakeEvents() {
-    return assertEx43(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx44(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get positions() {
     return this.params.positions;
@@ -6192,7 +6266,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._chainStakeEventsViewer = assertEx43(
+    this._chainStakeEventsViewer = assertEx44(
       await this.locateAndCreate(StakeEventsViewerMoniker2),
       () => "Failed to create StakeEventsViewer"
     );
@@ -6227,7 +6301,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     return toAddress(toAddress(1n));
   }
   stakeById(id) {
-    return assertEx43(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx44(this.positions[id], () => new Error(`Stake with id ${id} not found`));
   }
   stakeByStaker(staker, slot) {
     return this.positions.filter((s) => asXyoAddress4(s.staker) === asXyoAddress4(staker))[slot];
@@ -6329,12 +6403,12 @@ RestSyncViewer = __decorateClass([
 // src/simple/timeSync2/SimpleTimeSyncViewer.ts
 import {
   asHash as asHash5,
-  assertEx as assertEx44,
+  assertEx as assertEx45,
   isDefined as isDefined21
 } from "@xylabs/sdk-js";
 import {
   asTimePayload as asTimePayload2,
-  asXL1BlockNumber as asXL1BlockNumber10,
+  asXL1BlockNumber as asXL1BlockNumber11,
   BlockViewerMoniker as BlockViewerMoniker4,
   TimeSchema,
   TimeSyncViewerMoniker
@@ -6351,7 +6425,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx44(await this.blockViewer.blockByNumber(asXL1BlockNumber10(from, true)), () => "Block not found");
+        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);
@@ -6406,10 +6480,10 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
         return [Date.now(), null];
       }
       case "ethereum": {
-        const provider = assertEx44(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx45(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash5(assertEx44(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash5(assertEx45(block?.hash, () => "Block hash not found"), true);
         return [blockNumber, blockHash];
       }
       default: {
@@ -6424,7 +6498,7 @@ var SimpleTimeSyncViewer = class extends AbstractCreatableProvider {
       // this is for the previous block
       xl1,
       // this is for the previous block
-      xl1Hash: assertEx44(xl1Hash, () => "No xl1 hash available from time sync service"),
+      xl1Hash: assertEx45(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
     if (isDefined21(this.ethProvider)) {
@@ -6444,11 +6518,11 @@ SimpleTimeSyncViewer = __decorateClass([
 ], SimpleTimeSyncViewer);
 
 // src/simple/transactionValidation/SimpleTransactionValidationViewer.ts
-import { assertEx as assertEx45 } from "@xylabs/sdk-js";
+import { assertEx as assertEx46 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder24 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
-  asXL1BlockRange as asXL1BlockRange12,
+  asXL1BlockRange as asXL1BlockRange13,
   BlockViewerMoniker as BlockViewerMoniker5,
   ChainContractViewerMoniker as ChainContractViewerMoniker5,
   isChainQualifiedHeadConfig as isChainQualifiedHeadConfig6,
@@ -6495,7 +6569,7 @@ var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider
       head: void 0
     };
     const transactionsWithMeta = await Promise.all(transactions.map((b) => Promise.all([PayloadBuilder24.addHashMeta(b[0]), PayloadBuilder24.addHashMeta(b[1])])));
-    const head = isChainQualifiedHeadConfig6(config) ? assertEx45(
+    const head = isChainQualifiedHeadConfig6(config) ? assertEx46(
       (await this.blockViewer.blockByHash(config.head))?.[0],
       () => `Specified a head that is not in the chain [${config.head}]`
     ) : void 0;
@@ -6503,7 +6577,7 @@ var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider
     const validateProtocol = value ? this.doValidateProtocol.bind(this) : void 0;
     const validateState = state ? this.doValidateState.bind(this) : void 0;
     const chainId = headBlock.chain;
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange12([0, headBlock.block], true) };
+    const qualification = { head: headBlock._hash, range: asXL1BlockRange13([0, headBlock.block], true) };
     const [protocolResults, stateResults] = await Promise.all([
       validateProtocol?.(transactionsWithMeta, chainId),
       validateState?.(transactionsWithMeta, chainId)
@@ -6561,7 +6635,7 @@ SimpleTransactionValidationViewer = __decorateClass([
 ], SimpleTransactionValidationViewer);
 
 // src/simple/TransactionViewer/SimpleTransactionViewer.ts
-import { assertEx as assertEx46, exists as exists10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx47, exists as exists10 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema } from "@xyo-network/sdk-js";
 import {
   asSignedHydratedTransactionWithHashMeta,
@@ -6578,7 +6652,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
   }
   async byBlockHashAndIndex(blockHash, transactionIndex) {
     return await this.spanAsync("byBlockHashAndIndex", async () => {
-      assertEx46(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      assertEx47(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
       try {
         const block = await this.blockViewer.blockByHash(blockHash);
         if (!block) return null;
@@ -6642,13 +6716,15 @@ SimpleTransactionViewer = __decorateClass([
 
 // src/simple/windowedBlock/SimpleWindowedBlockViewer.ts
 import {
-  assertEx as assertEx47,
+  assertEx as assertEx48,
   exists as exists11,
   isNull as isNull2
 } from "@xylabs/sdk-js";
+import { MemoryMap as MemoryMap2 } from "@xyo-network/xl1-driver-memory";
 import {
-  asXL1BlockNumber as asXL1BlockNumber11,
+  asXL1BlockNumber as asXL1BlockNumber12,
   BlockViewerMoniker as BlockViewerMoniker7,
+  stepSize as stepSize3,
   WindowedBlockViewerMoniker as WindowedBlockViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 import { Mutex as Mutex2 } from "async-mutex";
@@ -6700,11 +6776,20 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     let block = this._blockNumberMap.get(blockNumber);
     while (block && (limit === void 0 || result.length < limit)) {
       result.unshift(block);
-      const previousBlockNumber = asXL1BlockNumber11(block[0].block - 1, true);
+      const previousBlockNumber = asXL1BlockNumber12(block[0].block - 1, true);
       block = previousBlockNumber >= 0 ? this._blockNumberMap.get(previousBlockNumber) : void 0;
     }
     return result;
   }
+  blocksByStep(stepLevel, stepIndex) {
+    const size = stepSize3(stepLevel);
+    const start = stepIndex * size;
+    const end = start + size - 1;
+    return this._chain.filter((block) => {
+      const blockNumber = block[0].block;
+      return blockNumber >= start && blockNumber <= end;
+    }).toReversed();
+  }
   blocksByTransactionHashes(hashes) {
     return hashes.map((hash) => this._transactionHashMap.get(hash)).filter(exists11);
   }
@@ -6713,22 +6798,22 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = assertEx47(
+    this._blockViewer = assertEx48(
       this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker7),
       () => "BlockViewer instance is required"
     );
-    this._blockHashMap = new MemoryMap();
-    this._blockNumberMap = new MemoryMap();
-    this._transactionHashMap = new MemoryMap();
+    this._blockHashMap = new MemoryMap2();
+    this._blockNumberMap = new MemoryMap2();
+    this._transactionHashMap = new MemoryMap2();
   }
   currentBlock() {
-    return assertEx47(this._chain.at(-1));
+    return assertEx48(this._chain.at(-1));
   }
   currentBlockHash() {
-    return assertEx47(this._chain.at(-1)?.[0]._hash);
+    return assertEx48(this._chain.at(-1)?.[0]._hash);
   }
   currentBlockNumber() {
-    return assertEx47(this._chain.at(-1)?.[0].block);
+    return assertEx48(this._chain.at(-1)?.[0].block);
   }
   async payloadByHash(hash) {
     const payloads = await this.payloadsByHash([hash]);
@@ -6886,14 +6971,375 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
   }
 };
 
+// src/test/buildRandomChain.ts
+import { asAddress as asAddress2, assertEx as assertEx51 } from "@xylabs/sdk-js";
+import {
+  Account as Account4,
+  asSchema as asSchema11,
+  IdSchema as IdSchema2,
+  MemoryArchivist,
+  PayloadBuilder as PayloadBuilder29
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber17
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildNextBlock.ts
+import {
+  AttoXL1 as AttoXL15,
+  XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS4
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildBlock.ts
+import { assertEx as assertEx49, isDefined as isDefined22 } from "@xylabs/sdk-js";
+import {
+  asAnyPayload as asAnyPayload5,
+  BoundWitnessBuilder as BoundWitnessBuilder3,
+  PayloadBuilder as PayloadBuilder25
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber13,
+  AttoXL1 as AttoXL14,
+  isBlockBoundWitness,
+  rewardAddressFromStepIdentity,
+  StepRewardFractions,
+  StepSizes as StepSizes15,
+  XL1_PROTOCOL_VERSION,
+  XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS3,
+  XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS2
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/BuildBlockOptions.ts
+import {
+  isAddress,
+  isArray as isArray2,
+  isHash as isHash3,
+  isNumber as isNumber2,
+  isObject as isObject3
+} from "@xylabs/sdk-js";
+var isBaseBuildBlockOptions = (value) => {
+  if (!isObject3(value)) {
+    return false;
+  }
+  const typedValue = value;
+  if (!isArray2(typedValue.blockPayloads) || !isAddress(typedValue.chainId) || !isArray2(typedValue.signers) || !isArray2(typedValue.txs)) {
+    return false;
+  }
+  return true;
+};
+var isBuildGenesisBlockOptions = (value) => {
+  if (!isBaseBuildBlockOptions(value)) {
+    return false;
+  }
+  const typedValue = value;
+  if (typedValue.previousBlockHash !== null) {
+    return false;
+  }
+  if (typedValue.previousBlockNumber !== void 0) {
+    return false;
+  }
+  return true;
+};
+var isBuildNextBlockOptions = (value) => {
+  if (!isBaseBuildBlockOptions(value)) {
+    return false;
+  }
+  const typedValue = value;
+  if (!isHash3(typedValue.previousBlockHash)) {
+    return false;
+  }
+  if (!isNumber2(typedValue.previousBlockNumber)) {
+    return false;
+  }
+  if (!isArray2(typedValue.previousStepHashes)) {
+    return false;
+  }
+  return true;
+};
+
+// src/test/buildBlock.ts
+function calculateCompletedStepReward(step, balance) {
+  return AttoXL14(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1]);
+}
+async function buildBlock(options) {
+  const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
+  const blockNumber = asXL1BlockNumber13(previousBlockNumber + 1, true);
+  const inStepHashes = isBuildNextBlockOptions(options) ? options.previousStepHashes : [];
+  const previousBlockHash = isBuildNextBlockOptions(options) ? options.previousBlockHash : void 0;
+  const stepRewardPoolBalance = isBuildNextBlockOptions(options) ? options.stepRewardPoolBalance : AttoXL14(0n);
+  const {
+    chainId,
+    txs,
+    chainStepRewardAddress: chainStepRewardAddress2 = XYO_STEP_REWARD_ADDRESS3,
+    blockPayloads,
+    protocol = XL1_PROTOCOL_VERSION,
+    signers
+  } = options;
+  const step_hashes = [];
+  for (const [tx] of txs) {
+    if (tx.nbf > blockNumber) {
+      throw new Error(`Transaction ${await PayloadBuilder25.hash(tx)} not valid for block ${blockNumber} - NBF is ${tx.nbf}`);
+    }
+    if (tx.exp < blockNumber) {
+      throw new Error(`Transaction ${await PayloadBuilder25.hash(tx)} not valid for block ${blockNumber} - EXP is ${tx.exp}`);
+    }
+  }
+  const completedStepRewardTransfers = [];
+  for (const [i, step] of StepSizes15.entries()) {
+    if (blockNumber < step) {
+      break;
+    }
+    if (blockNumber % step === 0) {
+      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress2 !== XYO_ZERO_ADDRESS2) {
+        const completedStepRewardHolderAddress = rewardAddressFromStepIdentity({ block: blockNumber, step });
+        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
+        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress2, { [completedStepRewardHolderAddress]: completedStepReward }));
+      }
+      step_hashes.push(assertEx49(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+    } else {
+      if (isDefined22(inStepHashes.at(i))) {
+        step_hashes.push(inStepHashes[i]);
+      }
+    }
+  }
+  const previous = previousBlockHash ?? null;
+  const block = blockNumber;
+  const txElevatedPayloads = await validateTransactionsOpcodes(txs);
+  const payloads = [
+    ...txs.map(([tx]) => tx),
+    ...blockPayloads,
+    ...txElevatedPayloads,
+    ...completedStepRewardTransfers
+  ];
+  const [bw, txPayloads] = await new BoundWitnessBuilder3().fields({
+    block,
+    chain: chainId,
+    previous,
+    step_hashes,
+    protocol
+  }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder25.addStorageMeta(payloads)).build();
+  assertEx49(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
+  return [await PayloadBuilder25.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload5(p, true))];
+}
+
+// src/test/buildNextBlock.ts
+async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainStepRewardAddress2 = XYO_STEP_REWARD_ADDRESS4, stepRewardPoolBalance = AttoXL15(0n), protocol, chainId) {
+  return await buildBlock({
+    chainId: chainId ?? previousBlock.chain,
+    previousBlockNumber: previousBlock.block,
+    previousStepHashes: previousBlock.step_hashes ?? [],
+    previousBlockHash: previousBlock._hash,
+    txs,
+    blockPayloads,
+    signers,
+    protocol,
+    chainStepRewardAddress: chainStepRewardAddress2,
+    stepRewardPoolBalance
+  });
+}
+
+// src/test/buildRandomGenesisBlock.ts
+import { asAddress, assertEx as assertEx50 } from "@xylabs/sdk-js";
+import {
+  Account as Account3,
+  asAnyPayload as asAnyPayload6,
+  asSchema as asSchema10,
+  IdSchema,
+  PayloadBuilder as PayloadBuilder26
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber15
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildGenesisBlock.ts
+import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS3 } from "@xyo-network/xl1-protocol-lib";
+async function buildGenesisBlock(chainId, txs, blockPayloads, signers, chainStepRewardAddress2 = XYO_ZERO_ADDRESS3, protocol) {
+  return await buildBlock({
+    previousBlockHash: null,
+    chainId,
+    txs,
+    blockPayloads,
+    signers,
+    chainStepRewardAddress: chainStepRewardAddress2,
+    protocol
+  });
+}
+
+// src/test/buildRandomTransaction.ts
+import { Account as Account2 } from "@xyo-network/sdk-js";
+import { asXL1BlockNumber as asXL1BlockNumber14, isAllowedBlockPayload as isAllowedBlockPayload3 } from "@xyo-network/xl1-protocol-lib";
+var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNumber14(0, true), exp = asXL1BlockNumber14(nbf + 1e3, true), privatePayloadSchemas = [], receiverAddress) => {
+  const elevatedPayloads = (payloads ?? []).filter(isAllowedBlockPayload3);
+  const additionalPayloads = (payloads ?? []).filter((payload) => !isAllowedBlockPayload3(payload));
+  const sender = account ?? await Account2.random();
+  if (elevatedPayloads.length === 0) {
+    const receiver = receiverAddress ?? (await Account2.random()).address;
+    const transferPayload = createTransferPayload(sender.address, { [receiver]: 1n });
+    elevatedPayloads.push(transferPayload);
+  }
+  const hydratedTransaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, sender, nbf, exp);
+  return [hydratedTransaction[0], hydratedTransaction[1].filter((payload) => !privatePayloadSchemas.includes(payload.schema))];
+};
+
+// src/test/buildRandomGenesisBlock.ts
+var TestChainId = assertEx50(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
+
+// src/test/createGenesisBlock.ts
+import { PayloadBuilder as PayloadBuilder28 } from "@xyo-network/sdk-js";
+import {
+  BlockBoundWitnessSchemaPayload,
+  BlockBoundWitnessWithStorageMetaSchemaPayload,
+  ChainStakeIntentPayloadJsonSchemaPayload,
+  HashPayloadJsonSchemaPayload,
+  TransactionBoundWitnessSchemaPayload,
+  TransactionBoundWitnessWithStorageMetaSchemaPayload,
+  TransferPayloadJsonSchemaPayload
+} from "@xyo-network/xl1-schema";
+
+// src/test/createProducerChainStakeIntentTransaction.ts
+import { PayloadBuilder as PayloadBuilder27 } from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber16,
+  ChainStakeIntentSchema as ChainStakeIntentSchema2,
+  defaultTransactionFees as defaultTransactionFees4
+} from "@xyo-network/xl1-protocol-lib";
+async function createProducerChainStakeIntent(from, exp, nbf = 0) {
+  return await PayloadBuilder27.addHashMeta(new PayloadBuilder27({ schema: ChainStakeIntentSchema2 }).fields({
+    from,
+    exp,
+    nbf,
+    intent: "producer"
+  }).build());
+}
+
+// src/test/createGenesisBlock.ts
+var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
+  const blockPayloads = await PayloadBuilder28.addHashMeta([
+    TransferPayloadJsonSchemaPayload,
+    BlockBoundWitnessSchemaPayload,
+    BlockBoundWitnessWithStorageMetaSchemaPayload,
+    TransactionBoundWitnessSchemaPayload,
+    TransactionBoundWitnessWithStorageMetaSchemaPayload,
+    ChainStakeIntentPayloadJsonSchemaPayload,
+    HashPayloadJsonSchemaPayload
+  ]);
+  const intentPayload = await createProducerChainStakeIntent(initialBlockProducer.address, 1, 0);
+  blockPayloads.push(intentPayload);
+  if (genesisBlockRewardAmount > 0n) {
+    blockPayloads.push(await PayloadBuilder28.addHashMeta(createTransferPayload(
+      nextContractAddress,
+      { [genesisBlockRewardAddress]: genesisBlockRewardAmount }
+    )));
+  }
+  return await buildGenesisBlock(nextContractAddress, [], blockPayloads, [initialBlockProducer]);
+};
+
+// src/test/buildRandomChain.ts
+var TestGenesisBlockRewardAddress = assertEx51(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
+var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId, transactionAccount, receiverAddresses) => {
+  const chainIdToUse = chainId ?? TestChainId;
+  const blocks = [];
+  let remaining = count;
+  let lastBlock = previousBlock;
+  const transactionAccountToUse = transactionAccount ?? await Account4.random();
+  if (!lastBlock) {
+    const block = await createGenesisBlock(
+      blockProducer,
+      chainIdToUse,
+      1000000000n * 10n ** 18n,
+      transactionAccountToUse.address
+    );
+    blocks.push(block);
+    remaining = remaining - 1;
+    lastBlock = block;
+  }
+  const resolvedReceiverAddresses = receiverAddresses ?? [(await Account4.random()).address];
+  let saltCounter = 0;
+  while (remaining > 0) {
+    saltCounter += 1;
+    const payloads = [new PayloadBuilder29({ schema: IdSchema2 }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()];
+    saltCounter += 1;
+    const additionalPrivatePayloads = remaining % 2 === 0 ? [new PayloadBuilder29({ schema: asSchema11("network.xyo.private", true) }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()] : [];
+    const txs = [];
+    for (const receiverAddress of resolvedReceiverAddresses) {
+      txs.push(await buildRandomTransaction(
+        chainIdToUse,
+        [...payloads, ...additionalPrivatePayloads],
+        transactionAccountToUse,
+        asXL1BlockNumber17(Math.max(count - remaining - 1e3, 0), true),
+        asXL1BlockNumber17(count - remaining + 1e3, true),
+        [asSchema11("network.xyo.private", true)],
+        receiverAddress
+      ));
+    }
+    const previousBlock2 = assertEx51(lastBlock?.[0], () => new Error("No last block"));
+    const block = await buildNextBlock(previousBlock2, txs, [], [blockProducer], transactionAccountToUse.address);
+    blocks.push(block);
+    remaining = remaining - 1;
+    lastBlock = block;
+  }
+  return blocks;
+};
+async function buildRandomChainArchivist(count = 20) {
+  const producerAccount = await Account4.random();
+  const blocks = await buildRandomChain(producerAccount, count);
+  const archivist = await MemoryArchivist.create();
+  const payloads = flattenHydratedBlocks(blocks);
+  await archivist.insert(payloads);
+  return archivist;
+}
+
+// src/test/getSimpleBlockViewerLocator.ts
+import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS4 } from "@xyo-network/xl1-protocol-lib";
+
+// src/_internal/context/getTestProviderContext.ts
+function getTestProviderContext(config) {
+  const singletons = {};
+  const caches = {};
+  const locator = new ProviderFactoryLocator({
+    config,
+    singletons,
+    caches,
+    logger: console
+  });
+  return locator.context;
+}
+
+// src/test/getSimpleBlockViewerLocator.ts
+async function getTestSimpleBlockViewerLocator({
+  minWithdrawalBlocks = 10,
+  config = ConfigZod.parse({}),
+  finalizedArchivist: finalizedArchivistIn,
+  rewardsContract = XYO_ZERO_ADDRESS4,
+  stakingTokenAddress = XYO_ZERO_ADDRESS4
+}) {
+  const finalizedArchivist = finalizedArchivistIn ?? await buildRandomChainArchivist();
+  const context = getTestProviderContext(config);
+  context.locator.registerMany([
+    SimpleChainContractViewer.factory(SimpleChainContractViewer.dependencies, {
+      minWithdrawalBlocks,
+      rewardsContract,
+      stakingTokenAddress
+    }),
+    SimpleFinalizationViewer.factory(SimpleFinalizationViewer.dependencies, { finalizedArchivist }),
+    SimpleBlockViewer.factory(SimpleBlockViewer.dependencies, { finalizedArchivist })
+  ]);
+  return context.locator;
+}
+
+// src/test/getTestProviderContext.ts
+function getTestProviderContext2(config) {
+  return getTestProviderContext(config);
+}
+
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx48 } from "@xylabs/sdk-js";
+import { assertEx as assertEx52 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol-lib";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
   const hydratedBlock = await hydrateBlock(context, blockHash);
   const timePayload = asTimePayload3(hydratedBlock[1].find((p) => p.schema === TimeSchema2), { required: true });
-  return assertEx48(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx52(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 
 // src/validation/lib/isLocalhost.ts
@@ -6911,8 +7357,8 @@ var getUrl = (host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z as z30 } from "zod";
-var MnemonicStringZod = z30.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+import { z as z31 } from "zod";
+var MnemonicStringZod = z31.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
   (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
   { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
 ).describe("BIP-39 mnemonic string");
@@ -6933,6 +7379,9 @@ var generateXyoBaseWalletFromPhrase = (walletPhrase) => {
   const wallet = HDWallet.fromPhrase(walletPhrase, DEFAULT_WALLET_PATH);
   return wallet;
 };
+
+// src/index.ts
+export * from "@xyo-network/xl1-driver-memory";
 export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,
@@ -6945,6 +7394,7 @@ export {
   BalancesStepSummarySchema,
   BaseConfigContextZod,
   BaseConfigZod,
+  BlocksStepSummarySchema,
   BoundWitnessHydrator,
   BoundWitnessWithStorageMetaZod,
   CHANGE_ADDRESS,
@@ -6972,8 +7422,6 @@ export {
   HydratedCache,
   JSONSchemaMetaSchema,
   LoggerStatusReporter,
-  LruCacheMap,
-  MemoryMap,
   MemoryPermissionsStore,
   MissingCapabilityError,
   MnemonicStringZod,
@@ -7025,6 +7473,7 @@ export {
   SimpleXyoSigner,
   StepSummarySchema,
   TODO,
+  TestGenesisBlockRewardAddress,
   TransactionBuilder,
   TransfersStepSummarySchema,
   TypedDataDomainZod,
@@ -7053,6 +7502,8 @@ export {
   asBalancesStepSummary,
   asBalancesStepSummaryWithStorageMeta,
   asBaseConfigContext,
+  asBlocksStepSummary,
+  asBlocksStepSummaryWithStorageMeta,
   asBoundWitnessWithStorageMeta,
   asChainIndexingServiceState,
   asChainIndexingServiceStateWithStorageMeta,
@@ -7077,6 +7528,12 @@ export {
   blockPayloadsFromHydratedBlock,
   blockRangeSteps,
   blockRate,
+  blocksMaxStep,
+  blocksStepSummaryFromRange,
+  blocksStepSummaryKey,
+  buildRandomChain,
+  buildRandomChainArchivist,
+  buildRandomTransaction,
   buildTransaction,
   buildUnsignedTransaction,
   bundledPayloadToHydratedBlock,
@@ -7115,11 +7572,14 @@ export {
   getEmptyContext,
   getEmptyProviderContext,
   getProducerKey,
+  getTestProviderContext2 as getTestProviderContext,
+  getTestSimpleBlockViewerLocator,
   getTimeConfigInMilliseconds,
   getUrl,
   getWindowedChain,
   hasLabels,
   hasMongoConfig,
+  hasR2Config,
   hashFromBlockNumber,
   hydrateBlock,
   hydrateElevatedTransaction,
@@ -7133,6 +7593,8 @@ export {
   isBalancesStepSummary,
   isBalancesStepSummaryWithStorageMeta,
   isBaseConfigContext,
+  isBlocksStepSummary,
+  isBlocksStepSummaryWithStorageMeta,
   isChainIndexingServiceState,
   isChainIndexingServiceStateWithStorageMeta,
   isCreatableProviderContext,