@xyo-network/xl1-protocol-sdk 2.0.11 → 2.0.13

package/dist/neutral/test/index.mjs

@@ -11,285 +11,825 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/test/buildRandomTransaction.ts
-import { Account } from "@xyo-network/sdk-js";
-import { asXL1BlockNumber, isAllowedBlockPayload } from "@xyo-network/xl1-protocol-lib";
-
-// src/createTransferPayload.ts
-import { toHex } from "@xylabs/sdk-js";
-import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { TransferSchema } from "@xyo-network/xl1-protocol-lib";
-function createTransferPayload(from, transfers, context) {
-  return new PayloadBuilder({ schema: TransferSchema }).fields({
-    epoch: Date.now(),
-    from,
-    transfers: Object.fromEntries(Object.entries(transfers).map(([k, v]) => [k, toHex(v)])),
-    context
-  }).build();
-}
-
-// src/transaction/buildTransaction.ts
-import { assertEx, toHex as toHex2 } from "@xylabs/sdk-js";
+// src/test/buildRandomChain.ts
+import { asAddress as asAddress2, assertEx as assertEx6 } from "@xylabs/sdk-js";
 import {
-  asAnyPayload,
-  BoundWitnessBuilder,
-  PayloadBuilder as PayloadBuilder2
+  Account as Account3,
+  asSchema as asSchema2,
+  IdSchema as IdSchema2,
+  MemoryArchivist,
+  PayloadBuilder as PayloadBuilder8
 } from "@xyo-network/sdk-js";
-import { defaultTransactionFees } from "@xyo-network/xl1-protocol-lib";
-async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
-  if (from === void 0 && Array.isArray(signer)) {
-    throw new Error("from is required when signer is an array");
-  }
-  const txBoundWitnessFields = {
-    chain,
-    fees: {
-      base: toHex2(fees.base),
-      gasLimit: toHex2(fees.gasLimit),
-      gasPrice: toHex2(fees.gasPrice),
-      priority: toHex2(fees.priority)
-    },
-    nbf,
-    exp
-  };
-  const elevatedHashes = await PayloadBuilder2.hashes(onChainPayloads);
-  const script = [];
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`);
-  }
-  const fields = {
-    ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx(signer.at(0)?.address) : signer.address)
-  };
-  if (script.length > 0) {
-    fields.script = script;
-  }
-  const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
-  return [await PayloadBuilder2.addHashMeta(tx), await PayloadBuilder2.addHashMeta(txPayloads.map((p) => asAnyPayload(p, true)))];
+import {
+  asXL1BlockNumber as asXL1BlockNumber6
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/block/hydrate/allHashesPresent.ts
+function allHashesPresent(hashes, payloads) {
+  const payloadHashes = new Set(payloads.map((p) => p._hash));
+  return hashes.every((hash) => payloadHashes.has(hash));
 }
 
-// src/test/buildRandomTransaction.ts
-var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNumber(0, true), exp = asXL1BlockNumber(nbf + 1e3, true), privatePayloadSchemas = [], receiverAddress) => {
-  const elevatedPayloads = (payloads ?? []).filter(isAllowedBlockPayload);
-  const additionalPayloads = (payloads ?? []).filter((payload) => !isAllowedBlockPayload(payload));
-  const sender = account ?? await Account.random();
-  if (elevatedPayloads.length === 0) {
-    const receiver = receiverAddress ?? (await Account.random()).address;
-    const 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/block/hydrate/flattenHydratedBlock.ts
+import { toHydratedBlock } from "@xyo-network/xl1-protocol-lib";
+var flattenHydratedBlock = (hydratedBlock) => {
+  const [blk, blkPayloads] = hydratedBlock;
+  return [...blkPayloads, blk];
 };
 
-// src/test/getSimpleBlockViewerLocator.ts
-import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS3 } from "@xyo-network/xl1-protocol-lib";
+// src/block/hydrate/flattenHydratedBlocks.ts
+var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
 
-// src/CreatableProvider/AbstractCreatableProvider.ts
+// src/block/hydrate/hydrateBlock.ts
+import { assertEx } from "@xylabs/sdk-js";
+import { asAnyPayload } from "@xyo-network/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
+  assertEx(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
+  assertEx(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
+  assertEx(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
+  const { chainMap } = context;
+  const [block] = await chainMap.get([hash]);
+  const bw = assertEx(asBlockBoundWitnessWithStorageMeta(
+    assertEx(block, () => `block ${hash} not found`)
+  ), () => `hash ${hash} is not a BlockBoundWitness`);
+  if (maxDepth === 0) return [bw, []];
+  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map((p) => asAnyPayload(p, true));
+  if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
+  if (maxDepth === 1) return [bw, blkPayloads];
+  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
+  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
+  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map((p) => asAnyPayload(p, true));
+  assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
+  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
+  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map((p) => asAnyPayload(p, true));
+  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
+  if (maxDepth === 2) assertEx(allHashesPresent(
+    [...allPayloadsHashes],
+    allPayloadsFiltered
+  ), () => `Unable to find all payloads for transactions in block ${hash}`);
+  return [bw, allPayloadsFiltered];
+};
+
+// src/block/primitives/blockFromBlockNumber.ts
 import {
-  AbstractCreatable,
-  assertEx as assertEx3,
-  IdLogger
+  asHash,
+  isDefined as isDefined2,
+  spanAsync
 } from "@xylabs/sdk-js";
+import { toSafeJsonString } from "@xylabs/sdk-js";
+import {
+  asSignedBlockBoundWitnessWithStorageMeta,
+  SignedBlockBoundWitnessWithHashMetaZod,
+  StepSizes
+} from "@xyo-network/xl1-protocol-lib";
 
-// src/CreatableProvider/ProviderFactory.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-function providerFactoryDescription(factory, labels) {
-  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? factory.labels ?? {})}`;
-}
-var ProviderFactory = class _ProviderFactory {
-  creatableProvider;
-  defaultMoniker;
-  defaultParams;
-  dependencies;
-  labels;
-  monikers;
-  providerName;
-  scope;
-  _uniqueId;
-  constructor(creatableProvider2, dependencies, params, labels = {}, scope = "context") {
-    this.creatableProvider = creatableProvider2;
-    this.defaultParams = params;
-    this.defaultMoniker = creatableProvider2.defaultMoniker;
-    this.dependencies = dependencies;
-    this.monikers = creatableProvider2.monikers;
-    this.scope = scope;
-    assertEx2(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
-    this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
-    this.providerName = creatableProvider2.name;
-    this._uniqueId = Symbol(providerFactoryDescription(this));
-  }
-  get resolvedMoniker() {
-    const labels = this.labels ?? {};
-    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
-    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`;
-  }
-  get uniqueId() {
-    return this._uniqueId;
+// src/ChainContextHelpers.ts
+import {
+  isDefined,
+  isObject,
+  isUndefined,
+  timeBudget
+} from "@xylabs/sdk-js";
+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");
   }
-  static withParams(creatableProvider2, dependencies, params, labels = {}) {
-    return new _ProviderFactory(creatableProvider2, dependencies, params, labels);
+  if (isUndefined(context.caches[name])) {
+    context.caches[name] = create?.() ?? new MemoryMap();
   }
-  factory(dependencies, params, labels = {}) {
-    return new _ProviderFactory(this.creatableProvider, dependencies, params, labels);
+  return context.caches[name];
+}
+async function withContextCacheResponse(context, name, key, func, { max = 1e4 } = {}) {
+  const cache = contextCache(
+    context,
+    name,
+    () => new LruCacheMap({ max })
+  );
+  const { timeBudgetLimit = 0 } = context;
+  const cacheResult = await cache.get(key);
+  if (isDefined(cacheResult)) {
+    return cacheResult;
   }
-  async getInstance(params, { start = true }) {
-    let scopeObject;
-    switch (this.scope) {
-      case "global": {
-        globalThis.xyoServiceSingletons ??= {};
-        scopeObject = globalThis.xyoServiceSingletons;
-        break;
+  const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func();
+  await cache.set(key, result);
+  return result;
+}
+
+// src/block/primitives/blockFromBlockNumber.ts
+async function blockFromBlockNumber(context, blockNumber) {
+  return await spanAsync("blockFromBlockNumber", async () => {
+    const cacheKey = `${blockNumber}`;
+    const { chainMap, head } = context;
+    return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
+      const [result] = await chainMap.get([head._hash]);
+      if (!isDefined2(result)) {
+        throw new Error(`Head block not found for hash: ${head._hash}`);
       }
-      case "context": {
-        const context = assertEx2(
-          params?.context,
-          () => "Context is required for context-scoped providers"
-        );
-        context.singletons ??= {};
-        scopeObject = context.singletons;
-        break;
+      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
+        result,
+        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`
+      );
+      if (currentBlock.block < blockNumber) {
+        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
       }
-      default: {
-        scopeObject = {};
-        break;
+      while (currentBlock.block > blockNumber) {
+        let jumpHash = currentBlock.previous;
+        let jumpBlockNumber = currentBlock.block - 1;
+        for (const [step, stepSize3] of StepSizes.entries()) {
+          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize3 - 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}`);
+          }
+        }
+        const [newBlock] = await chainMap.get([
+          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
+        ]);
+        if (!isDefined2(newBlock)) {
+          throw new Error(`Block not found for jump hash: ${jumpHash}`);
+        }
+        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
+          newBlock,
+          () => {
+            const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
+            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
+          }
+        );
+        if (currentBlock.block === blockNumber) {
+          break;
+        }
+        if (currentBlock.block < blockNumber) {
+          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`);
+        }
       }
+      return currentBlock;
+    });
+  }, { ...context, timeBudgetLimit: 500 });
+}
+
+// src/block/primitives/frames/calculateFramesFromRange.ts
+import { asXL1BlockNumber, stepSize } from "@xyo-network/xl1-protocol-lib";
+function calculateFramesFromRange(range, step) {
+  const size = stepSize(step);
+  let start = Math.trunc(range[0] / size) * size;
+  const fitted = [];
+  const remaining = [];
+  if (start !== range[0]) {
+    start += size;
+    remaining.push([range[0], asXL1BlockNumber(Math.min(start - 1, range[1]), true)]);
+  }
+  for (let i = start; i <= range[1]; i += size) {
+    if (i + size - 1 <= range[1]) {
+      fitted.push([
+        asXL1BlockNumber(i, { name: "calculateFramesFromRange A" }),
+        asXL1BlockNumber(Math.min(i + size - 1, range[1]), { name: "calculateFramesFromRange B" })
+      ]);
+    } else {
+      remaining.push([asXL1BlockNumber(i, { name: "calculateFramesFromRange C" }), range[1]]);
     }
-    const mergedParams = {
-      ...this.defaultParams,
-      ...params
-    };
-    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
-    scopeObject[this.resolvedMoniker] = resultPromise;
-    const result = await resultPromise;
-    if (start) {
-      assertEx2(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`);
-    }
-    return result;
   }
-  async tryGetInstance(params, options) {
-    try {
-      return await this.getInstance(params, options);
-    } catch {
-      return;
+  return [fitted, remaining];
+}
+
+// src/block/primitives/frames/deepCalculateFramesFromRange.ts
+import { StepSizes as StepSizes2 } from "@xyo-network/xl1-protocol-lib";
+function deepCalculateFramesFromRange(range, startingStep = StepSizes2.length - 1) {
+  const fitted = [];
+  let remaining = [range];
+  const actualStartingStep = Math.min(startingStep, StepSizes2.length - 1);
+  for (let step = actualStartingStep; step >= 0; step--) {
+    const newRemaining = [];
+    for (const range2 of remaining) {
+      const [newFittedFrames, newRemainingFrames] = calculateFramesFromRange(range2, step);
+      fitted.push(...newFittedFrames);
+      newRemaining.push(...newRemainingFrames);
     }
+    remaining = newRemaining;
   }
-};
-
-// src/CreatableProvider/AbstractCreatableProvider.ts
-var AbstractCreatableProvider = class extends AbstractCreatable {
-  dependencies = {};
-  _contextCache;
-  _logger;
-  get logger() {
-    if (this._logger === void 0) {
-      const providedLogger = this.params.logger ?? this.context.logger;
-      this._logger = providedLogger ? new IdLogger(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null;
+  for (const range2 of remaining) {
+    for (let i = range2[0]; i <= range2[1]; i++) {
+      fitted.push([i, i]);
     }
-    return this._logger ?? void 0;
   }
-  get meter() {
-    return this.context.meterProvider?.getMeter(this.name) ?? super.meter;
+  return fitted.toSorted((a, b) => a[0] - b[0]);
+}
+
+// src/block/primitives/validateTransactionOpcodes.ts
+import {
+  assertEx as assertEx2,
+  isHash,
+  toSafeJsonString as toSafeJsonString2
+} from "@xylabs/sdk-js";
+import {
+  PayloadBuilder
+} from "@xyo-network/sdk-js";
+import { isExecutable } from "@xyo-network/xl1-protocol-lib";
+async function validateTransactionsOpcodes(txs) {
+  const txElevatedPayloads = [];
+  for (const [txBw, txPayloads] of txs) {
+    if (isExecutable(txBw)) {
+      const operations = txBw.script.map((op) => op.split("|"));
+      for (const [opCode, ...args] of operations) {
+        switch (opCode) {
+          case "elevate": {
+            const [hash, ...rest] = args;
+            const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads);
+            assertEx2(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
+            if (isHash(hash)) {
+              assertEx2(
+                txBw.payload_hashes.includes(hash),
+                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
+              );
+              const txPayload = assertEx2(
+                txPayloadsWithStorageMeta.find((p) => p._hash === hash),
+                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
+              );
+              txElevatedPayloads.push(txPayload);
+            } else {
+              throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
+            }
+            break;
+          }
+          default: {
+            throw new Error(`Invalid opCode ${opCode}`);
+          }
+        }
+      }
+    }
   }
-  get tracer() {
-    return this.context.traceProvider?.getTracer(this.name) ?? super.tracer;
+  return txElevatedPayloads;
+}
+
+// src/test/buildNextBlock.ts
+import {
+  AttoXL1 as AttoXL12,
+  XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS2
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildBlock.ts
+import { assertEx as assertEx3, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import {
+  asAnyPayload as asAnyPayload2,
+  BoundWitnessBuilder,
+  PayloadBuilder as PayloadBuilder3
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber2,
+  AttoXL1,
+  isBlockBoundWitness,
+  rewardAddressFromStepIdentity,
+  StepRewardFractions,
+  StepSizes as StepSizes3,
+  XL1_PROTOCOL_VERSION,
+  XYO_STEP_REWARD_ADDRESS,
+  XYO_ZERO_ADDRESS
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/createTransferPayload.ts
+import { toHex } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { TransferSchema } from "@xyo-network/xl1-protocol-lib";
+function createTransferPayload(from, transfers, context) {
+  return new PayloadBuilder2({ schema: TransferSchema }).fields({
+    epoch: Date.now(),
+    from,
+    transfers: Object.fromEntries(Object.entries(transfers).map(([k, v]) => [k, toHex(v)])),
+    context
+  }).build();
+}
+
+// src/test/BuildBlockOptions.ts
+import {
+  isAddress,
+  isArray,
+  isHash as isHash2,
+  isNumber,
+  isObject as isObject2
+} from "@xylabs/sdk-js";
+var isBaseBuildBlockOptions = (value) => {
+  if (!isObject2(value)) {
+    return false;
   }
-  get config() {
-    return this.context.config;
+  const typedValue = value;
+  if (!isArray(typedValue.blockPayloads) || !isAddress(typedValue.chainId) || !isArray(typedValue.signers) || !isArray(typedValue.txs)) {
+    return false;
   }
-  get context() {
-    return this.params.context;
+  return true;
+};
+var isBuildGenesisBlockOptions = (value) => {
+  if (!isBaseBuildBlockOptions(value)) {
+    return false;
   }
-  get locator() {
-    return this.context.locator;
+  const typedValue = value;
+  if (typedValue.previousBlockHash !== null) {
+    return false;
   }
-  static factory(dependencies, params) {
-    const factory = ProviderFactory.withParams(this, dependencies, params);
-    return factory;
+  if (typedValue.previousBlockNumber !== void 0) {
+    return false;
   }
-  static async paramsHandler(params = {}) {
-    const context = assertEx3(params.context, () => new Error("Context is required"));
-    const config = assertEx3(context.config, () => new Error("Context config is required"));
-    const locator = assertEx3(context.locator, () => new Error("Context locator is required"));
-    return await super.paramsHandler({
-      ...params,
-      statusReporter: params.statusReporter ?? context.statusReporter,
-      context: {
-        ...context,
-        config,
-        locator
-      },
-      name: params.name ?? this.defaultMoniker,
-      logger: params.logger ?? context.logger
-    });
+  return true;
+};
+var isBuildNextBlockOptions = (value) => {
+  if (!isBaseBuildBlockOptions(value)) {
+    return false;
   }
-  async createHandler() {
-    await super.createHandler();
-    if (this.tracer === void 0) {
-      this.logger?.warn("No tracer available in context");
-    }
-    if (this.meter === void 0) {
-      this.logger?.warn("No meter available in context");
-    }
+  const typedValue = value;
+  if (!isHash2(typedValue.previousBlockHash)) {
+    return false;
   }
-  async locateAndCreate(moniker) {
-    return await this.locator.getInstance(moniker);
+  if (!isNumber(typedValue.previousBlockNumber)) {
+    return false;
   }
-  async tryLocateAndCreate(moniker) {
-    return await this.locator.tryGetInstance(moniker);
+  if (!isArray(typedValue.previousStepHashes)) {
+    return false;
   }
+  return true;
 };
 
-// src/CreatableProvider/CreatableProvider.ts
-function creatableProvider() {
-  return (constructor) => {
-    constructor;
-  };
+// src/test/buildBlock.ts
+function calculateCompletedStepReward(step, balance) {
+  return AttoXL1(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1]);
 }
-
-// src/CreatableProvider/CreatableProviderRegistry.ts
-import { isTruthy } from "@xylabs/sdk-js";
-var buildProviderFactory = (provider, defaultParams, labels) => {
-  const factory = {
-    monikers: provider.monikers,
-    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
-    // Merge module & supplied labels
-    labels: { ...provider.labels, ...labels },
-    creatableProvider: provider.creatableProvider,
-    dependencies: provider.dependencies,
-    resolvedMoniker: provider.resolvedMoniker,
-    providerName: provider.providerName,
-    scope: provider.scope,
-    defaultParams,
-    getInstance: provider.getInstance.bind(provider),
-    tryGetInstance: provider.tryGetInstance?.bind(provider),
-    defaultMoniker: provider.defaultMoniker,
-    factory: provider.factory.bind(provider)
-  };
-  return factory;
-};
-var registerCreatableProviderFactory = (registry, factory, labels, primary = false) => {
-  const primaryMonikers = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
-  for (const primaryMoniker of primaryMonikers) {
-    if (!factory.monikers.includes(primaryMoniker)) {
-      throw new Error(`Primary moniker ${String(primaryMoniker)} not found in factory monikers`);
+async function buildBlock(options) {
+  const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
+  const blockNumber = asXL1BlockNumber2(previousBlockNumber + 1, true);
+  const inStepHashes = isBuildNextBlockOptions(options) ? options.previousStepHashes : [];
+  const previousBlockHash = isBuildNextBlockOptions(options) ? options.previousBlockHash : void 0;
+  const stepRewardPoolBalance = isBuildNextBlockOptions(options) ? options.stepRewardPoolBalance : AttoXL1(0n);
+  const {
+    chainId,
+    txs,
+    chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS,
+    blockPayloads,
+    protocol = XL1_PROTOCOL_VERSION,
+    signers
+  } = options;
+  const step_hashes = [];
+  for (const [tx] of txs) {
+    if (tx.nbf > blockNumber) {
+      throw new Error(`Transaction ${await PayloadBuilder3.hash(tx)} not valid for block ${blockNumber} - NBF is ${tx.nbf}`);
+    }
+    if (tx.exp < blockNumber) {
+      throw new Error(`Transaction ${await PayloadBuilder3.hash(tx)} not valid for block ${blockNumber} - EXP is ${tx.exp}`);
     }
   }
-  const isPrimaryForMoniker = (moniker) => {
-    switch (typeof primary) {
-      case "boolean": {
-        return primary;
-      }
-      case "string": {
-        return moniker === primary;
+  const completedStepRewardTransfers = [];
+  for (const [i, step] of StepSizes3.entries()) {
+    if (blockNumber < step) {
+      break;
+    }
+    if (blockNumber % step === 0) {
+      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress !== XYO_ZERO_ADDRESS) {
+        const completedStepRewardHolderAddress = rewardAddressFromStepIdentity({ block: blockNumber, step });
+        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
+        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }));
       }
-      case "object": {
-        if (Array.isArray(primary)) {
-          return primary.includes(moniker);
-        }
+      step_hashes.push(assertEx3(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+    } else {
+      if (isDefined3(inStepHashes.at(i))) {
+        step_hashes.push(inStepHashes[i]);
       }
     }
-    throw new Error(`Invalid primary value: ${String(primary)}`);
-  };
+  }
+  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 BoundWitnessBuilder().fields({
+    block,
+    chain: chainId,
+    previous,
+    step_hashes,
+    protocol
+  }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder3.addStorageMeta(payloads)).build();
+  assertEx3(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
+  return [await PayloadBuilder3.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload2(p, true))];
+}
+
+// src/test/buildNextBlock.ts
+async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS2, stepRewardPoolBalance = AttoXL12(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,
+    stepRewardPoolBalance
+  });
+}
+
+// src/test/buildRandomGenesisBlock.ts
+import { asAddress, assertEx as assertEx5 } from "@xylabs/sdk-js";
+import {
+  Account as Account2,
+  asAnyPayload as asAnyPayload4,
+  asSchema,
+  IdSchema,
+  PayloadBuilder as PayloadBuilder5
+} from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber4
+} from "@xyo-network/xl1-protocol-lib";
+
+// src/test/buildGenesisBlock.ts
+import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS2 } from "@xyo-network/xl1-protocol-lib";
+async function buildGenesisBlock(chainId, txs, blockPayloads, signers, chainStepRewardAddress = XYO_ZERO_ADDRESS2, protocol) {
+  return await buildBlock({
+    previousBlockHash: null,
+    chainId,
+    txs,
+    blockPayloads,
+    signers,
+    chainStepRewardAddress,
+    protocol
+  });
+}
+
+// src/test/buildRandomTransaction.ts
+import { Account } from "@xyo-network/sdk-js";
+import { asXL1BlockNumber as asXL1BlockNumber3, isAllowedBlockPayload } from "@xyo-network/xl1-protocol-lib";
+
+// src/transaction/buildTransaction.ts
+import { assertEx as assertEx4, toHex as toHex2 } from "@xylabs/sdk-js";
+import {
+  asAnyPayload as asAnyPayload3,
+  BoundWitnessBuilder as BoundWitnessBuilder2,
+  PayloadBuilder as PayloadBuilder4
+} from "@xyo-network/sdk-js";
+import { defaultTransactionFees } from "@xyo-network/xl1-protocol-lib";
+async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
+  if (from === void 0 && Array.isArray(signer)) {
+    throw new Error("from is required when signer is an array");
+  }
+  const txBoundWitnessFields = {
+    chain,
+    fees: {
+      base: toHex2(fees.base),
+      gasLimit: toHex2(fees.gasLimit),
+      gasPrice: toHex2(fees.gasPrice),
+      priority: toHex2(fees.priority)
+    },
+    nbf,
+    exp
+  };
+  const elevatedHashes = await PayloadBuilder4.hashes(onChainPayloads);
+  const script = [];
+  for (const elevatedHash of elevatedHashes) {
+    script.push(`elevate|${elevatedHash}`);
+  }
+  const fields = {
+    ...txBoundWitnessFields,
+    from: from ?? (Array.isArray(signer) ? assertEx4(signer.at(0)?.address) : signer.address)
+  };
+  if (script.length > 0) {
+    fields.script = script;
+  }
+  const [tx, txPayloads] = await new BoundWitnessBuilder2().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
+  return [await PayloadBuilder4.addHashMeta(tx), await PayloadBuilder4.addHashMeta(txPayloads.map((p) => asAnyPayload3(p, true)))];
+}
+
+// src/test/buildRandomTransaction.ts
+var buildRandomTransaction = async (chain, payloads, account, nbf = asXL1BlockNumber3(0, true), exp = asXL1BlockNumber3(nbf + 1e3, true), privatePayloadSchemas = [], receiverAddress) => {
+  const elevatedPayloads = (payloads ?? []).filter(isAllowedBlockPayload);
+  const additionalPayloads = (payloads ?? []).filter((payload) => !isAllowedBlockPayload(payload));
+  const sender = account ?? await Account.random();
+  if (elevatedPayloads.length === 0) {
+    const receiver = receiverAddress ?? (await Account.random()).address;
+    const 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 = assertEx5(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
+
+// src/test/createGenesisBlock.ts
+import { PayloadBuilder as PayloadBuilder7 } 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 PayloadBuilder6 } from "@xyo-network/sdk-js";
+import {
+  asXL1BlockNumber as asXL1BlockNumber5,
+  ChainStakeIntentSchema,
+  defaultTransactionFees as defaultTransactionFees2
+} from "@xyo-network/xl1-protocol-lib";
+async function createProducerChainStakeIntent(from, exp, nbf = 0) {
+  return await PayloadBuilder6.addHashMeta(new PayloadBuilder6({ schema: ChainStakeIntentSchema }).fields({
+    from,
+    exp,
+    nbf,
+    intent: "producer"
+  }).build());
+}
+
+// src/test/createGenesisBlock.ts
+var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
+  const blockPayloads = await PayloadBuilder7.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 PayloadBuilder7.addHashMeta(createTransferPayload(
+      nextContractAddress,
+      { [genesisBlockRewardAddress]: genesisBlockRewardAmount }
+    )));
+  }
+  return await buildGenesisBlock(nextContractAddress, [], blockPayloads, [initialBlockProducer]);
+};
+
+// src/test/buildRandomChain.ts
+var TestGenesisBlockRewardAddress = assertEx6(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 Account3.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 Account3.random()).address];
+  let saltCounter = 0;
+  while (remaining > 0) {
+    saltCounter += 1;
+    const payloads = [new PayloadBuilder8({ schema: IdSchema2 }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()];
+    saltCounter += 1;
+    const additionalPrivatePayloads = remaining % 2 === 0 ? [new PayloadBuilder8({ schema: asSchema2("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,
+        asXL1BlockNumber6(Math.max(count - remaining - 1e3, 0), true),
+        asXL1BlockNumber6(count - remaining + 1e3, true),
+        [asSchema2("network.xyo.private", true)],
+        receiverAddress
+      ));
+    }
+    const previousBlock2 = assertEx6(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 Account3.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_ADDRESS3 } from "@xyo-network/xl1-protocol-lib";
+
+// src/CreatableProvider/AbstractCreatableProvider.ts
+import {
+  AbstractCreatable,
+  assertEx as assertEx8,
+  IdLogger
+} from "@xylabs/sdk-js";
+
+// src/CreatableProvider/ProviderFactory.ts
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+function providerFactoryDescription(factory, labels) {
+  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? factory.labels ?? {})}`;
+}
+var ProviderFactory = class _ProviderFactory {
+  creatableProvider;
+  defaultMoniker;
+  defaultParams;
+  dependencies;
+  labels;
+  monikers;
+  providerName;
+  scope;
+  _uniqueId;
+  constructor(creatableProvider2, dependencies, params, labels = {}, scope = "context") {
+    this.creatableProvider = creatableProvider2;
+    this.defaultParams = params;
+    this.defaultMoniker = creatableProvider2.defaultMoniker;
+    this.dependencies = dependencies;
+    this.monikers = creatableProvider2.monikers;
+    this.scope = scope;
+    assertEx7(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
+    this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
+    this.providerName = creatableProvider2.name;
+    this._uniqueId = Symbol(providerFactoryDescription(this));
+  }
+  get resolvedMoniker() {
+    const labels = this.labels ?? {};
+    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(",");
+    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`;
+  }
+  get uniqueId() {
+    return this._uniqueId;
+  }
+  static withParams(creatableProvider2, dependencies, params, labels = {}) {
+    return new _ProviderFactory(creatableProvider2, dependencies, params, labels);
+  }
+  factory(dependencies, params, labels = {}) {
+    return new _ProviderFactory(this.creatableProvider, dependencies, params, labels);
+  }
+  async getInstance(params, { start = true }) {
+    let scopeObject;
+    switch (this.scope) {
+      case "global": {
+        globalThis.xyoServiceSingletons ??= {};
+        scopeObject = globalThis.xyoServiceSingletons;
+        break;
+      }
+      case "context": {
+        const context = assertEx7(
+          params?.context,
+          () => "Context is required for context-scoped providers"
+        );
+        context.singletons ??= {};
+        scopeObject = context.singletons;
+        break;
+      }
+      default: {
+        scopeObject = {};
+        break;
+      }
+    }
+    const mergedParams = {
+      ...this.defaultParams,
+      ...params
+    };
+    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
+    scopeObject[this.resolvedMoniker] = resultPromise;
+    const result = await resultPromise;
+    if (start) {
+      assertEx7(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`);
+    }
+    return result;
+  }
+  async tryGetInstance(params, options) {
+    try {
+      return await this.getInstance(params, options);
+    } catch {
+      return;
+    }
+  }
+};
+
+// src/CreatableProvider/AbstractCreatableProvider.ts
+var AbstractCreatableProvider = class extends AbstractCreatable {
+  dependencies = {};
+  _contextCache;
+  _logger;
+  get logger() {
+    if (this._logger === void 0) {
+      const providedLogger = this.params.logger ?? this.context.logger;
+      this._logger = providedLogger ? new IdLogger(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null;
+    }
+    return this._logger ?? void 0;
+  }
+  get meter() {
+    return this.context.meterProvider?.getMeter(this.name) ?? super.meter;
+  }
+  get tracer() {
+    return this.context.traceProvider?.getTracer(this.name) ?? super.tracer;
+  }
+  get config() {
+    return this.context.config;
+  }
+  get context() {
+    return this.params.context;
+  }
+  get locator() {
+    return this.context.locator;
+  }
+  static factory(dependencies, params) {
+    const factory = ProviderFactory.withParams(this, dependencies, params);
+    return factory;
+  }
+  static async paramsHandler(params = {}) {
+    const context = assertEx8(params.context, () => new Error("Context is required"));
+    const config = assertEx8(context.config, () => new Error("Context config is required"));
+    const locator = assertEx8(context.locator, () => new Error("Context locator is required"));
+    return await super.paramsHandler({
+      ...params,
+      statusReporter: params.statusReporter ?? context.statusReporter,
+      context: {
+        ...context,
+        config,
+        locator
+      },
+      name: params.name ?? this.defaultMoniker,
+      logger: params.logger ?? context.logger
+    });
+  }
+  async createHandler() {
+    await super.createHandler();
+    if (this.tracer === void 0) {
+      this.logger?.warn("No tracer available in context");
+    }
+    if (this.meter === void 0) {
+      this.logger?.warn("No meter available in context");
+    }
+  }
+  async locateAndCreate(moniker) {
+    return await this.locator.getInstance(moniker);
+  }
+  async tryLocateAndCreate(moniker) {
+    return await this.locator.tryGetInstance(moniker);
+  }
+};
+
+// src/CreatableProvider/CreatableProvider.ts
+function creatableProvider() {
+  return (constructor) => {
+    constructor;
+  };
+}
+
+// src/CreatableProvider/CreatableProviderRegistry.ts
+import { isTruthy } from "@xylabs/sdk-js";
+var buildProviderFactory = (provider, defaultParams, labels) => {
+  const factory = {
+    monikers: provider.monikers,
+    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
+    // Merge module & supplied labels
+    labels: { ...provider.labels, ...labels },
+    creatableProvider: provider.creatableProvider,
+    dependencies: provider.dependencies,
+    resolvedMoniker: provider.resolvedMoniker,
+    providerName: provider.providerName,
+    scope: provider.scope,
+    defaultParams,
+    getInstance: provider.getInstance.bind(provider),
+    tryGetInstance: provider.tryGetInstance?.bind(provider),
+    defaultMoniker: provider.defaultMoniker,
+    factory: provider.factory.bind(provider)
+  };
+  return factory;
+};
+var registerCreatableProviderFactory = (registry, factory, labels, primary = false) => {
+  const primaryMonikers = primary !== true && isTruthy(primary) ? Array.isArray(primary) ? primary : [primary] : [];
+  for (const primaryMoniker of primaryMonikers) {
+    if (!factory.monikers.includes(primaryMoniker)) {
+      throw new Error(`Primary moniker ${String(primaryMoniker)} not found in factory monikers`);
+    }
+  }
+  const isPrimaryForMoniker = (moniker) => {
+    switch (typeof primary) {
+      case "boolean": {
+        return primary;
+      }
+      case "string": {
+        return moniker === primary;
+      }
+      case "object": {
+        if (Array.isArray(primary)) {
+          return primary.includes(moniker);
+        }
+      }
+    }
+    throw new Error(`Invalid primary value: ${String(primary)}`);
+  };
   const factoryClone = buildProviderFactory(factory, factory.defaultParams, labels);
   registry[factoryClone.defaultMoniker] = [factoryClone, ...registry[factoryClone.defaultMoniker] ?? []];
   for (const moniker of factoryClone.monikers) {
@@ -305,7 +845,7 @@ var hasLabels = (factory) => {
 
 // src/CreatableProvider/ProviderFactoryLocator.ts
 import { hasAllLabels } from "@xylabs/sdk-js";
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
 var ProviderFactoryLocator = class _ProviderFactoryLocator {
   _context;
   _registry;
@@ -337,7 +877,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
     this._frozen = true;
   }
   async getInstance(moniker, { start = true, labels } = {}) {
-    return assertEx4(
+    return assertEx9(
       await this.tryGetInstance(moniker, { start, labels }),
       () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} could be created`
     );
@@ -352,7 +892,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
    * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
    */
   locate(moniker, labels) {
-    return assertEx4(
+    return assertEx9(
       this.tryLocate(moniker, labels),
       () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`
     );
@@ -374,10 +914,10 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
    * @param labels The labels for the module factory
    */
   register(factory, labels, primary = false) {
-    assertEx4(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
+    assertEx9(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
     if (this.validateDepsOnRegister) {
       const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
-      assertEx4(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(", ")}`);
+      assertEx9(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(", ")}`);
     }
     registerCreatableProviderFactory(this._registry, factory, labels, primary);
     return this;
@@ -425,7 +965,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
     for (const moniker in this.registry) {
       for (const factory of this.registry[moniker] ?? []) {
         const missingDeps = factory.dependencies.filter((dep) => !this.registered(dep));
-        assertEx4(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(", ")}`);
+        assertEx9(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(", ")}`);
       }
     }
   }
@@ -450,10 +990,10 @@ import {
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry12, z as z16 } from "zod/mini";
+import { globalRegistry as globalRegistry13, z as z17 } from "zod/mini";
 
 // src/config/Base.ts
-import { z as z15 } from "zod/mini";
+import { z as z16 } from "zod/mini";
 
 // src/config/Chain.ts
 import { HexZod } from "@xylabs/sdk-js";
@@ -623,7 +1163,7 @@ var RpcRemoteConfigZod = z10.union([HttpRpcRemoteConfigZod, PostMessageRpcRemote
 var RemoteConfigZod = z10.object({ rpc: RpcRemoteConfigZod.optional() }).describe("Configuration for remote connections, including RPC");
 
 // src/config/storage/driver/Mongo.ts
-import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry8, z as z11 } from "zod";
 var MongoConfigZod = z11.object({
   // TODO: Create from other arguments
@@ -654,11 +1194,43 @@ var MongoConfigZod = z11.object({
   })
 });
 
-// src/config/storage/Storage.ts
+// src/config/storage/driver/R2.ts
+import { isDefined as isDefined5, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
 import { globalRegistry as globalRegistry9, z as z12 } from "zod";
-var StorageConfigZod = z12.object({
+var R2ConfigZod = z12.object({
+  accessKeyId: z12.string().nonempty().optional().register(globalRegistry9, {
+    description: "Cloudflare R2 access key id (from an R2 API token)",
+    title: "storage.r2.accessKeyId",
+    type: "string"
+  }),
+  accountId: z12.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: z12.string().nonempty().optional().register(globalRegistry9, {
+    description: "Cloudflare R2 bucket name",
+    title: "storage.r2.bucket",
+    type: "string"
+  }),
+  prefix: z12.string().nonempty().optional().register(globalRegistry9, {
+    description: "Optional key prefix namespacing this store within the bucket",
+    title: "storage.r2.prefix",
+    type: "string"
+  }),
+  secretAccessKey: z12.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 z13 } from "zod";
+var StorageConfigZod = z13.object({
   mongo: MongoConfigZod.optional().describe("Configuration for the MongoD storage driver"),
-  root: z12.string().optional().register(globalRegistry9, {
+  r2: R2ConfigZod.optional().describe("Configuration for the Cloudflare R2 storage driver"),
+  root: z13.string().optional().register(globalRegistry10, {
     description: "Root directory for local storage",
     title: "storage.root",
     type: "string"
@@ -666,30 +1238,30 @@ var StorageConfigZod = z12.object({
 }).describe("Storage configuration options");
 
 // src/config/Telemetry.ts
-import { globalRegistry as globalRegistry10, z as z13 } from "zod";
-var MetricsScrapeConfigZod = z13.object({
-  path: z13.string().default("/metrics").register(globalRegistry10, {
+import { globalRegistry as globalRegistry11, z as z14 } from "zod";
+var MetricsScrapeConfigZod = z14.object({
+  path: z14.string().default("/metrics").register(globalRegistry11, {
     default: "/metrics",
     description: "Path for the metrics scrape endpoint",
     title: "telemetry.metrics.scrape.path",
     type: "string"
   }),
-  port: z13.coerce.number().int().positive().optional().register(globalRegistry10, {
+  port: z14.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 = z13.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
-var OpenTelemetryConfigZod = z13.object({
+var MetricsConfigZod = z14.object({ scrape: MetricsScrapeConfigZod }).describe("Metrics configuration options");
+var OpenTelemetryConfigZod = z14.object({
   // OpenTelemetry options
-  otlpEndpoint: z13.url().optional().register(globalRegistry10, {
+  otlpEndpoint: z14.url().optional().register(globalRegistry11, {
     description: "OTLP endpoint for exporting telemetry data",
     title: "telemetry.otel.otlpEndpoint",
     type: "string"
   })
 });
-var TelemetryConfigZod = z13.object({
+var TelemetryConfigZod = z14.object({
   // Metrics configuration
   metrics: MetricsConfigZod.optional().describe("Metrics configuration"),
   // OpenTelemetry configuration
@@ -698,14 +1270,14 @@ var TelemetryConfigZod = z13.object({
 
 // src/config/Validation.ts
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/address";
-import { globalRegistry as globalRegistry11, z as z14 } from "zod";
+import { globalRegistry as globalRegistry12, z as z15 } from "zod";
 
 // src/primitives/block/rate/blockRate.ts
-import { isDefined as isDefined3, isFalsy } from "@xylabs/sdk-js";
+import { isDefined as isDefined7, isFalsy } from "@xylabs/sdk-js";
 import { asXL1BlockRange } from "@xyo-network/xl1-protocol-lib";
 
 // src/primitives/block/rate/timeHelpers.ts
-import { assertEx as assertEx5, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, isDefined as isDefined6 } from "@xylabs/sdk-js";
 var rateMultipliers = {
   millis: 1,
   seconds: 1e3,
@@ -723,7 +1295,7 @@ var timeDurations = (timeInMs) => ({
   weeks: timeInMs / (1e3 * 60 * 60 * 24 * 7)
 });
 var getTimeConfigInMilliseconds = (timeConfig) => {
-  const assertedTimeConfig = assertEx5(isDefined2(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
+  const assertedTimeConfig = assertEx10(isDefined6(timeConfig) ? timeConfig : void 0, () => "Time configuration must be provided");
   let totalMilliseconds = 0;
   if ("years" in assertedTimeConfig) {
     totalMilliseconds += assertedTimeConfig.years * 31536e6;
@@ -762,366 +1334,130 @@ var blockRate = (startBlock, endBlock, timeUnit) => {
     throw new Error("Time difference must be greater than 0");
   }
   const rate = heightDifference / timeDifference;
-  const timeUnitValue = isDefined3(timeUnit) ? timeUnit : "millis";
-  const returnedTimeDifference = isDefined3(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
+  const timeUnitValue = isDefined7(timeUnit) ? timeUnit : "millis";
+  const returnedTimeDifference = isDefined7(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference;
   const timePerBlock = returnedTimeDifference / heightDifference;
   return {
     range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
     span: heightDifference,
-    rate: isDefined3(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
+    rate: isDefined7(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
     timeUnit: timeUnitValue,
     timeDifference: returnedTimeDifference,
     timePerBlock
   };
 };
-var getBlockRateBlocks = async (viewer, startBlockHeight, endBlockHeight) => {
-  if (endBlockHeight <= startBlockHeight) {
-    throw new Error(`End block height must be greater than start block height [start=${startBlockHeight}, end=${endBlockHeight}]`);
-  }
-  const startingBlock = await viewer.blockByNumber(startBlockHeight);
-  const endingBlock = await viewer.blockByNumber(endBlockHeight);
-  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
-    throw new Error("Could not retrieve blocks for speed calculation");
-  }
-  return { startingBlock, endingBlock };
-};
-var calculateBlockRate = async (viewer, range, timeUnit) => {
-  const [startBlockHeight, endBlockHeight] = range;
-  const { startingBlock, endingBlock } = await getBlockRateBlocks(
-    viewer,
-    startBlockHeight,
-    endBlockHeight
-  );
-  return blockRate(startingBlock, endingBlock, timeUnit);
-};
-
-// src/primitives/block/rate/stepRate.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import {
-  asXL1BlockRange as asXL1BlockRange2,
-  isValidStep,
-  StepSizes
-} from "@xyo-network/xl1-protocol-lib";
-var stepRate = async (viewer, start, step, count = 1, timeUnit) => {
-  const end = start + step * count;
-  const range = asXL1BlockRange2([start, end], true);
-  return await calculateBlockRate(viewer, range, timeUnit);
-};
-var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit) => {
-  assertEx6(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
-  const step = StepSizes[stepIndex];
-  return await stepRate(viewer, start, step, count, timeUnit);
-};
-
-// src/primitives/block/rate/timeRate.ts
-import {
-  assertEx as assertEx7,
-  isDefined as isDefined4,
-  isDefinedNotNull
-} from "@xylabs/sdk-js";
-import { asXL1BlockNumber as asXL1BlockNumber2, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
-var DEFAULT_TOLERANCE_MS = 3e4;
-var DEFAULT_MAX_ATTEMPTS = 10;
-var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
-  assertEx7(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
-  const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
-  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock[0] : (await viewer.currentBlock())[0];
-  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
-  assertEx7(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
-  const blocksPerMillisecondRate = 1 / (12 * 1e3);
-  const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
-  const endBlockNumber = await findEndBlockRecursive(
-    viewer,
-    resolvedStartBlock,
-    timeInMilliseconds,
-    initialBlocksInDuration,
-    toleranceMs,
-    maxAttempts
-  );
-  return await calculateBlockRate(
-    viewer,
-    asXL1BlockRange3([endBlockNumber, resolvedStartBlock.block], true),
-    timeUnit
-  );
-};
-var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
-  assertEx7(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
-  const startBlockEpoch = startBlock.$epoch;
-  const estimatedEndBlockNumber = asXL1BlockNumber2(startBlock.block - estimatedBlocksBack, true);
-  if (estimatedEndBlockNumber < 0) {
-    throw new Error("Estimated end block number is less than zero");
-  }
-  const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
-  const resolvedEndBlock = assertEx7(
-    isDefined4(endBlock?.[0]) ? endBlock[0] : void 0,
-    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
-  );
-  const endBlockEpoch = resolvedEndBlock.$epoch;
-  if (!Number.isFinite(startBlockEpoch) || !Number.isFinite(endBlockEpoch)) {
-    throw new TypeError("Block has missing or invalid $epoch");
-  }
-  const actualTimeDifference = startBlockEpoch - endBlockEpoch;
-  if (actualTimeDifference === 0) {
-    throw new Error("Start and end blocks have identical timestamps");
-  }
-  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs);
-  if (timeDelta <= toleranceMs) {
-    return resolvedEndBlock.block;
-  }
-  let adjustedBlocksBack;
-  if (actualTimeDifference < targetTimeMs) {
-    const adjustmentFactor = targetTimeMs / actualTimeDifference;
-    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor);
-  } else {
-    const adjustmentFactor = actualTimeDifference / targetTimeMs;
-    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor);
-  }
-  adjustedBlocksBack = Number.isFinite(adjustedBlocksBack) && adjustedBlocksBack >= 1 ? adjustedBlocksBack : 1;
-  return await findEndBlockRecursive(
-    viewer,
-    startBlock,
-    targetTimeMs,
-    adjustedBlocksBack,
-    toleranceMs,
-    attemptsRemaining - 1
-  );
-};
-
-// src/ChainContextHelpers.ts
-import {
-  isDefined as isDefined5,
-  isObject,
-  isUndefined as isUndefined2,
-  timeBudget
-} from "@xylabs/sdk-js";
-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");
-  }
-  if (isUndefined2(context.caches[name])) {
-    context.caches[name] = create?.() ?? new MemoryMap();
-  }
-  return context.caches[name];
-}
-async function withContextCacheResponse(context, name, key, func, { max = 1e4 } = {}) {
-  const cache = contextCache(
-    context,
-    name,
-    () => new LruCacheMap({ max })
-  );
-  const { timeBudgetLimit = 0 } = context;
-  const cacheResult = await cache.get(key);
-  if (isDefined5(cacheResult)) {
-    return cacheResult;
-  }
-  const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func();
-  await cache.set(key, result);
-  return result;
-}
-
-// src/block/hydrate/allHashesPresent.ts
-function allHashesPresent(hashes, payloads) {
-  const payloadHashes = new Set(payloads.map((p) => p._hash));
-  return hashes.every((hash) => payloadHashes.has(hash));
-}
-
-// src/block/hydrate/flattenHydratedBlock.ts
-import { toHydratedBlock } from "@xyo-network/xl1-protocol-lib";
-var flattenHydratedBlock = (hydratedBlock) => {
-  const [blk, blkPayloads] = hydratedBlock;
-  return [...blkPayloads, blk];
-};
-
-// src/block/hydrate/flattenHydratedBlocks.ts
-var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) => flattenHydratedBlock(blk));
-
-// src/block/hydrate/hydrateBlock.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
-import { asAnyPayload as asAnyPayload2 } from "@xyo-network/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
-var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
-  assertEx8(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
-  assertEx8(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
-  assertEx8(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
-  const { chainMap } = context;
-  const [block] = await chainMap.get([hash]);
-  const bw = assertEx8(asBlockBoundWitnessWithStorageMeta(
-    assertEx8(block, () => `block ${hash} not found`)
-  ), () => `hash ${hash} is not a BlockBoundWitness`);
-  if (maxDepth === 0) return [bw, []];
-  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map((p) => asAnyPayload2(p, true));
-  if (minDepth === 1) assertEx8(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`);
-  if (maxDepth === 1) return [bw, blkPayloads];
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta);
-  const transactionsPayloadHashes = transactions.flatMap((tx) => tx.payload_hashes);
-  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map((p) => asAnyPayload2(p, true));
-  assertEx8(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`);
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap((p) => p._hash));
-  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map((p) => asAnyPayload2(p, true));
-  const allPayloadsFiltered = allPayloads.filter((p) => allPayloadsHashes.has(p._hash));
-  if (maxDepth === 2) assertEx8(allHashesPresent(
-    [...allPayloadsHashes],
-    allPayloadsFiltered
-  ), () => `Unable to find all payloads for transactions in block ${hash}`);
-  return [bw, allPayloadsFiltered];
-};
-
-// src/block/primitives/blockFromBlockNumber.ts
-import {
-  asHash,
-  isDefined as isDefined6,
-  spanAsync
-} from "@xylabs/sdk-js";
-import { toSafeJsonString } from "@xylabs/sdk-js";
-import {
-  asSignedBlockBoundWitnessWithStorageMeta,
-  SignedBlockBoundWitnessWithHashMetaZod,
-  StepSizes as StepSizes2
-} from "@xyo-network/xl1-protocol-lib";
-async function blockFromBlockNumber(context, blockNumber) {
-  return await spanAsync("blockFromBlockNumber", async () => {
-    const cacheKey = `${blockNumber}`;
-    const { chainMap, head } = context;
-    return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
-      const [result] = await chainMap.get([head._hash]);
-      if (!isDefined6(result)) {
-        throw new Error(`Head block not found for hash: ${head._hash}`);
-      }
-      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-        result,
-        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`
-      );
-      if (currentBlock.block < blockNumber) {
-        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`);
-      }
-      while (currentBlock.block > blockNumber) {
-        let jumpHash = currentBlock.previous;
-        let jumpBlockNumber = currentBlock.block - 1;
-        for (const [step, stepSize3] of StepSizes2.entries()) {
-          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize3 - 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}`);
-          }
-        }
-        const [newBlock] = await chainMap.get([
-          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
-        ]);
-        if (!isDefined6(newBlock)) {
-          throw new Error(`Block not found for jump hash: ${jumpHash}`);
-        }
-        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-          newBlock,
-          () => {
-            const result2 = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock);
-            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result2.error}`;
-          }
-        );
-        if (currentBlock.block === blockNumber) {
-          break;
-        }
-        if (currentBlock.block < blockNumber) {
-          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`);
-        }
-      }
-      return currentBlock;
-    });
-  }, { ...context, timeBudgetLimit: 500 });
-}
-
-// src/block/primitives/frames/calculateFramesFromRange.ts
-import { asXL1BlockNumber as asXL1BlockNumber3, stepSize } from "@xyo-network/xl1-protocol-lib";
-function calculateFramesFromRange(range, step) {
-  const size = stepSize(step);
-  let start = Math.trunc(range[0] / size) * size;
-  const fitted = [];
-  const remaining = [];
-  if (start !== range[0]) {
-    start += size;
-    remaining.push([range[0], asXL1BlockNumber3(Math.min(start - 1, range[1]), true)]);
-  }
-  for (let i = start; i <= range[1]; i += size) {
-    if (i + size - 1 <= range[1]) {
-      fitted.push([
-        asXL1BlockNumber3(i, { name: "calculateFramesFromRange A" }),
-        asXL1BlockNumber3(Math.min(i + size - 1, range[1]), { name: "calculateFramesFromRange B" })
-      ]);
-    } else {
-      remaining.push([asXL1BlockNumber3(i, { name: "calculateFramesFromRange C" }), range[1]]);
-    }
-  }
-  return [fitted, remaining];
-}
-
-// src/block/primitives/frames/deepCalculateFramesFromRange.ts
-import { StepSizes as StepSizes3 } from "@xyo-network/xl1-protocol-lib";
-function deepCalculateFramesFromRange(range, startingStep = StepSizes3.length - 1) {
-  const fitted = [];
-  let remaining = [range];
-  const actualStartingStep = Math.min(startingStep, StepSizes3.length - 1);
-  for (let step = actualStartingStep; step >= 0; step--) {
-    const newRemaining = [];
-    for (const range2 of remaining) {
-      const [newFittedFrames, newRemainingFrames] = calculateFramesFromRange(range2, step);
-      fitted.push(...newFittedFrames);
-      newRemaining.push(...newRemainingFrames);
-    }
-    remaining = newRemaining;
+var getBlockRateBlocks = async (viewer, startBlockHeight, endBlockHeight) => {
+  if (endBlockHeight <= startBlockHeight) {
+    throw new Error(`End block height must be greater than start block height [start=${startBlockHeight}, end=${endBlockHeight}]`);
   }
-  for (const range2 of remaining) {
-    for (let i = range2[0]; i <= range2[1]; i++) {
-      fitted.push([i, i]);
-    }
+  const startingBlock = await viewer.blockByNumber(startBlockHeight);
+  const endingBlock = await viewer.blockByNumber(endBlockHeight);
+  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
+    throw new Error("Could not retrieve blocks for speed calculation");
   }
-  return fitted.toSorted((a, b) => a[0] - b[0]);
-}
+  return { startingBlock, endingBlock };
+};
+var calculateBlockRate = async (viewer, range, timeUnit) => {
+  const [startBlockHeight, endBlockHeight] = range;
+  const { startingBlock, endingBlock } = await getBlockRateBlocks(
+    viewer,
+    startBlockHeight,
+    endBlockHeight
+  );
+  return blockRate(startingBlock, endingBlock, timeUnit);
+};
 
-// src/block/primitives/validateTransactionOpcodes.ts
+// src/primitives/block/rate/stepRate.ts
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
 import {
-  assertEx as assertEx9,
-  isHash,
-  toSafeJsonString as toSafeJsonString2
-} from "@xylabs/sdk-js";
+  asXL1BlockRange as asXL1BlockRange2,
+  isValidStep,
+  StepSizes as StepSizes4
+} from "@xyo-network/xl1-protocol-lib";
+var stepRate = async (viewer, start, step, count = 1, timeUnit) => {
+  const end = start + step * count;
+  const range = asXL1BlockRange2([start, end], true);
+  return await calculateBlockRate(viewer, range, timeUnit);
+};
+var calculateStepSizeRate = async (viewer, start, stepIndex, count = 1, timeUnit) => {
+  assertEx11(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`);
+  const step = StepSizes4[stepIndex];
+  return await stepRate(viewer, start, step, count, timeUnit);
+};
+
+// src/primitives/block/rate/timeRate.ts
 import {
-  PayloadBuilder as PayloadBuilder3
-} from "@xyo-network/sdk-js";
-import { isExecutable } from "@xyo-network/xl1-protocol-lib";
-async function validateTransactionsOpcodes(txs) {
-  const txElevatedPayloads = [];
-  for (const [txBw, txPayloads] of txs) {
-    if (isExecutable(txBw)) {
-      const operations = txBw.script.map((op) => op.split("|"));
-      for (const [opCode, ...args] of operations) {
-        switch (opCode) {
-          case "elevate": {
-            const [hash, ...rest] = args;
-            const txPayloadsWithStorageMeta = await PayloadBuilder3.addStorageMeta(txPayloads);
-            assertEx9(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
-            if (isHash(hash)) {
-              assertEx9(
-                txBw.payload_hashes.includes(hash),
-                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Hash not in payload hashes => ${toSafeJsonString2(txBw, 20)}`
-              );
-              const txPayload = assertEx9(
-                txPayloadsWithStorageMeta.find((p) => p._hash === hash),
-                () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Payload not found`
-              );
-              txElevatedPayloads.push(txPayload);
-            } else {
-              throw new Error(`Invalid elevate operation ${opCode} ${args.join(", ")} - Invalid hash`);
-            }
-            break;
-          }
-          default: {
-            throw new Error(`Invalid opCode ${opCode}`);
-          }
-        }
-      }
-    }
+  assertEx as assertEx12,
+  isDefined as isDefined8,
+  isDefinedNotNull
+} from "@xylabs/sdk-js";
+import { asXL1BlockNumber as asXL1BlockNumber7, asXL1BlockRange as asXL1BlockRange3 } from "@xyo-network/xl1-protocol-lib";
+var DEFAULT_TOLERANCE_MS = 3e4;
+var DEFAULT_MAX_ATTEMPTS = 10;
+var calculateTimeRate = async (viewer, timeConfig, startBlockNumber, timeUnit, toleranceMs = DEFAULT_TOLERANCE_MS, maxAttempts = DEFAULT_MAX_ATTEMPTS) => {
+  assertEx12(Object.keys(timeConfig ?? {}).length === 1, () => "Only one time unit should be specified in timeConfig");
+  const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null;
+  const resolvedStartBlock = isDefinedNotNull(startBlock) ? startBlock[0] : (await viewer.currentBlock())[0];
+  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig);
+  assertEx12(timeInMilliseconds > 0, () => "Time duration must be greater than zero");
+  const blocksPerMillisecondRate = 1 / (12 * 1e3);
+  const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds);
+  const endBlockNumber = await findEndBlockRecursive(
+    viewer,
+    resolvedStartBlock,
+    timeInMilliseconds,
+    initialBlocksInDuration,
+    toleranceMs,
+    maxAttempts
+  );
+  return await calculateBlockRate(
+    viewer,
+    asXL1BlockRange3([endBlockNumber, resolvedStartBlock.block], true),
+    timeUnit
+  );
+};
+var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBlocksBack, toleranceMs, attemptsRemaining) => {
+  assertEx12(attemptsRemaining >= 0, () => "Maximum attempts reached while searching for end block");
+  const startBlockEpoch = startBlock.$epoch;
+  const estimatedEndBlockNumber = asXL1BlockNumber7(startBlock.block - estimatedBlocksBack, true);
+  if (estimatedEndBlockNumber < 0) {
+    throw new Error("Estimated end block number is less than zero");
   }
-  return txElevatedPayloads;
-}
+  const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber);
+  const resolvedEndBlock = assertEx12(
+    isDefined8(endBlock?.[0]) ? endBlock[0] : void 0,
+    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`
+  );
+  const endBlockEpoch = resolvedEndBlock.$epoch;
+  if (!Number.isFinite(startBlockEpoch) || !Number.isFinite(endBlockEpoch)) {
+    throw new TypeError("Block has missing or invalid $epoch");
+  }
+  const actualTimeDifference = startBlockEpoch - endBlockEpoch;
+  if (actualTimeDifference === 0) {
+    throw new Error("Start and end blocks have identical timestamps");
+  }
+  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs);
+  if (timeDelta <= toleranceMs) {
+    return resolvedEndBlock.block;
+  }
+  let adjustedBlocksBack;
+  if (actualTimeDifference < targetTimeMs) {
+    const adjustmentFactor = targetTimeMs / actualTimeDifference;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor);
+  } else {
+    const adjustmentFactor = actualTimeDifference / targetTimeMs;
+    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor);
+  }
+  adjustedBlocksBack = Number.isFinite(adjustedBlocksBack) && adjustedBlocksBack >= 1 ? adjustedBlocksBack : 1;
+  return await findEndBlockRecursive(
+    viewer,
+    startBlock,
+    targetTimeMs,
+    adjustedBlocksBack,
+    toleranceMs,
+    attemptsRemaining - 1
+  );
+};
 
 // src/primitives/state/findMostRecentBlock.ts
 import { isSignedBlockBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
@@ -1151,7 +1487,7 @@ var findMostRecentBlock = async (chainArchivist, nextOptions = DEFAULT_NEXT_OPTI
 };
 
 // src/primitives/state/hydratedBlockByNumber.ts
-import { assertEx as assertEx10, spanAsync as spanAsync2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx13, spanAsync as spanAsync2 } from "@xylabs/sdk-js";
 async function hydratedBlockByNumber(context, blockNumber) {
   return await spanAsync2("hydratedBlockByNumber", async () => {
     if (blockNumber < 0) throw new Error(`Block number ${blockNumber} is less than 0`);
@@ -1159,7 +1495,7 @@ async function hydratedBlockByNumber(context, blockNumber) {
     if (blockNumber % 1 !== 0) throw new Error(`Block number ${blockNumber} is not an integer`);
     const cacheKey = `${blockNumber}`;
     return await withContextCacheResponse(context, "hydratedBlockByNumber", cacheKey, async () => {
-      const block = assertEx10(
+      const block = assertEx13(
         await blockFromBlockNumber(context, blockNumber),
         () => `Could not find block for block number ${blockNumber}`
       );
@@ -1173,24 +1509,24 @@ var DEFAULT_MIN_CANDIDATES = 1;
 var DEFAULT_BACKOFF_MS = 12e4;
 
 // src/config/Validation.ts
-var ValidationConfigZod = z14.object({
-  allowedRewardRedeemers: z14.array(XyoAddressZod2).optional().register(globalRegistry11, {
+var ValidationConfigZod = z15.object({
+  allowedRewardRedeemers: z15.array(XyoAddressZod2).optional().register(globalRegistry12, {
     description: "List of allowed reward redeemer addresses, if undefined anyone can participate",
     title: "allowedRewardRedeemers",
     type: "array"
   }),
-  allowedRewardEscrowAccountSigners: z14.array(XyoAddressZod2).optional().register(globalRegistry11, {
+  allowedRewardEscrowAccountSigners: z15.array(XyoAddressZod2).optional().register(globalRegistry12, {
     description: "List of allowed reward escrow account signer addresses, if undefined anyone can participate",
     title: "allowedRewardEscrowAccountSigners",
     type: "array"
   }),
-  minCandidates: z14.coerce.number().default(DEFAULT_MIN_CANDIDATES).register(globalRegistry11, {
+  minCandidates: z15.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: z14.coerce.number().default(DEFAULT_BACKOFF_MS).register(globalRegistry11, {
+  backoffMs: z15.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",
@@ -1199,26 +1535,26 @@ var ValidationConfigZod = z14.object({
 });
 
 // src/config/Base.ts
-var BaseConfigZod = z15.object({
-  chain: z15._default(ChainConfigZod, ChainConfigZod.parse({})).check(z15.describe("Configuration for the chain")),
-  dataLake: z15.optional(DataLakeConfigZod).check(z15.describe("Configuration for data lakes")),
-  evm: z15._default(EvmConfigZod, EvmConfigZod.parse({})).check(z15.describe("Configuration for EVM-backed services")),
-  log: z15._default(LogConfigZod, LogConfigZod.parse({})).check(z15.describe("Configuration for logging")),
-  providers: z15._default(ProvidersConfigZod, ProvidersConfigZod.parse([])).check(z15.describe("Configuration for providers")),
-  remote: z15._default(RemoteConfigZod, RemoteConfigZod.parse({})).check(z15.describe("Configuration for remote services")),
-  storage: z15._default(StorageConfigZod, StorageConfigZod.parse({})).check(z15.describe("Configuration for the storage")),
-  telemetry: z15._default(TelemetryConfigZod, TelemetryConfigZod.parse({})).check(z15.describe("Configuration for telemetry")),
-  validation: z15._default(ValidationConfigZod, ValidationConfigZod.parse({})).check(z15.describe("Configuration for validation"))
+var BaseConfigZod = z16.object({
+  chain: z16._default(ChainConfigZod, ChainConfigZod.parse({})).check(z16.describe("Configuration for the chain")),
+  dataLake: z16.optional(DataLakeConfigZod).check(z16.describe("Configuration for data lakes")),
+  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"))
 });
 
 // src/config/Actor.ts
-var AccountPathZod = z16.string().check(z16.regex(
+var AccountPathZod = z17.string().check(z17.regex(
   /^(m(\/\d+'?)+|\d+'?(\/\d+'?)*)$/,
   `Invalid BIP-32 derivation path. Use either an absolute path like "m/44'/60'/0'/0/0" or a relative path like "0", "0/1", or "44'/60'/0'/0/0".`
 ));
-var ActorConfigZod = z16.extend(BaseConfigZod, {
-  name: z16.string(),
-  accountPath: z16.optional(AccountPathZod).register(globalRegistry12, {
+var ActorConfigZod = z17.extend(BaseConfigZod, {
+  name: z17.string(),
+  accountPath: z17.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"
@@ -1229,31 +1565,31 @@ var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
-import { z as z17 } from "zod/mini";
-var ActorsConfigZod = z17._default(
-  z17.array(z17.looseObject(ActorConfigZod.shape)).check(z17.describe("Actor-specific configurations that override the base configuration when the actor is running")),
+import { z as z18 } from "zod/mini";
+var ActorsConfigZod = z18._default(
+  z18.array(z18.looseObject(ActorConfigZod.shape)).check(z18.describe("Actor-specific configurations that override the base configuration when the actor is running")),
   []
 );
 
 // src/config/Config.ts
-import { globalRegistry as globalRegistry13, z as z18 } from "zod/mini";
-var ConfigZod = z18.extend(BaseConfigZod, {
+import { globalRegistry as globalRegistry14, z as z19 } from "zod/mini";
+var ConfigZod = z19.extend(BaseConfigZod, {
   actors: ActorsConfigZod,
-  healthCheckPort: z18.optional(z18.coerce.number()).register(globalRegistry13, {
+  healthCheckPort: z19.optional(z19.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(z18.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
+}).check(z19.describe("The complete configuration for the protocol, including global settings and actor-specific overrides"));
 
 // src/summary/model/BlocksStepSummary.ts
 import { AsObjectFactory } from "@xylabs/sdk-js";
 import {
-  asSchema,
+  asSchema as asSchema3,
   isPayloadOfSchemaType,
   isStorageMeta
 } from "@xyo-network/sdk-js";
-var BlocksStepSummarySchema = asSchema("network.xyo.step.summary.blocks", true);
+var BlocksStepSummarySchema = asSchema3("network.xyo.step.summary.blocks", true);
 var isBlocksStepSummary = isPayloadOfSchemaType(BlocksStepSummarySchema);
 var asBlocksStepSummary = AsObjectFactory.create(isBlocksStepSummary);
 var isBlocksStepSummaryWithStorageMeta = (value) => {
@@ -1265,9 +1601,9 @@ var asBlocksStepSummaryWithStorageMeta = AsObjectFactory.create(isBlocksStepSumm
 var blocksMaxStep = 3;
 
 // src/summary/primitives/blocks/blocksStepSummaryFromRange.ts
-import { assertEx as assertEx11, spanRootAsync } from "@xylabs/sdk-js";
+import { assertEx as assertEx14, spanRootAsync } from "@xylabs/sdk-js";
 import { isAnyPayload } from "@xyo-network/sdk-js";
-import { asXL1BlockNumber as asXL1BlockNumber4, StepSizes as StepSizes4 } from "@xyo-network/xl1-protocol-lib";
+import { asXL1BlockNumber as asXL1BlockNumber8, StepSizes as StepSizes5 } from "@xyo-network/xl1-protocol-lib";
 function blocksStepSummaryKey(frameHeadHash, frameSize) {
   return `${frameHeadHash}|${frameSize}`;
 }
@@ -1275,7 +1611,7 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
   const cacheKey = `${range[0]}|${range[1]}`;
   return await withContextCacheResponse(context, "blocksStepSummaryFromRange", cacheKey, async () => {
     return await spanRootAsync("blocksStepSummaryFromRange", async () => {
-      const frameHead = assertEx11(
+      const frameHead = assertEx14(
         await blockViewer.blockByNumber(range[1]),
         () => `Block not found for number: ${range[1]}`
       );
@@ -1290,8 +1626,8 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
           blocks: [frameHead]
         };
       } else {
-        const step = StepSizes4.indexOf(asXL1BlockNumber4(frameSize, true));
-        assertEx11(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes4.join(", ")}`);
+        const step = StepSizes5.indexOf(asXL1BlockNumber8(frameSize, true));
+        assertEx14(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes5.join(", ")}`);
         const key = blocksStepSummaryKey(frameHeadHash, frameSize);
         const summaryResult = await summaryMap.get(key);
         if (isAnyPayload(summaryResult)) {
@@ -1327,20 +1663,20 @@ async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summ
 
 // src/simple/block/SimpleBlockViewer.ts
 import {
-  assertEx as assertEx12,
+  assertEx as assertEx15,
   exists,
-  isUndefined as isUndefined3
+  isUndefined as isUndefined4
 } from "@xylabs/sdk-js";
 import { LruCacheMap as LruCacheMap2 } from "@xyo-network/xl1-driver-memory";
 import {
   asSignedHydratedBlockWithHashMeta,
   asSignedHydratedBlockWithStorageMeta,
-  asXL1BlockNumber as asXL1BlockNumber5,
+  asXL1BlockNumber as asXL1BlockNumber9,
   asXL1BlockRange as asXL1BlockRange4,
   BlockViewerMoniker,
   FinalizationViewerMoniker,
   stepSize as stepSize2,
-  StepSizes as StepSizes5
+  StepSizes as StepSizes6
 } from "@xyo-network/xl1-protocol-lib";
 import { Semaphore } from "async-mutex";
 
@@ -1375,7 +1711,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   finalizationViewer;
   payloadCache = new LruCacheMap2({ max: 1e4 });
   signedHydratedBlockWithHashMetaCache = new LruCacheMap2({ max: 2e3, ttl: 1e3 * 60 * 60 });
-  _blockStepSemaphores = StepSizes5.map(() => new Semaphore(20));
+  _blockStepSemaphores = StepSizes6.map(() => new Semaphore(20));
   _blocksSummaryMap;
   _headPollHash;
   _headPollInProgress = false;
@@ -1406,12 +1742,12 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     const headPollIntervalMs = params.headPollIntervalMs;
     if (headPollIntervalMs !== void 0) {
-      assertEx12(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
+      assertEx15(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
     }
     return {
       ...await super.paramsHandler(params),
       blocksSummaryMap: params.blocksSummaryMap,
-      finalizedArchivist: assertEx12(params.finalizedArchivist, () => "finalizedArchivist is required"),
+      finalizedArchivist: assertEx15(params.finalizedArchivist, () => "finalizedArchivist is required"),
       headPollIntervalMs
     };
   }
@@ -1432,7 +1768,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   async blockByNumber(blockNumber) {
     return await this.spanAsync("blockByNumber", async () => {
       const chainContext = await this.getChainContextRead();
-      if (isUndefined3(chainContext.head)) {
+      if (isUndefined4(chainContext.head)) {
         return null;
       }
       return await this.blockByNumberWithContext(chainContext, blockNumber);
@@ -1440,8 +1776,8 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByHash(hash, limit = 50) {
     return await this.spanAsync("blocksByHash", async () => {
-      assertEx12(limit > 0, () => "limit must be greater than 0");
-      assertEx12(limit <= 100, () => "limit must be less than 100");
+      assertEx15(limit > 0, () => "limit must be greater than 0");
+      assertEx15(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -1455,10 +1791,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByNumber(blockNumber, limit = 50) {
     return await this.spanAsync("blocksByNumber", async () => {
-      assertEx12(limit > 0, () => "limit must be greater than 0");
-      assertEx12(limit <= 100, () => "limit must be less than 100");
+      assertEx15(limit > 0, () => "limit must be greater than 0");
+      assertEx15(limit <= 100, () => "limit must be less than 100");
       const chainContext = await this.getChainContextRead();
-      if (isUndefined3(chainContext.head)) {
+      if (isUndefined4(chainContext.head)) {
         return [];
       }
       const blocks = [];
@@ -1466,7 +1802,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
       while (current && blocks.length < limit) {
         blocks.push(current);
         if (current[0].block === 0) break;
-        const previousNumber = asXL1BlockNumber5(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));
@@ -1474,14 +1810,14 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByStep(stepLevel, stepIndex) {
     return await this.spanAsync("blocksByStep", async () => {
-      assertEx12(Number.isInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
+      assertEx15(Number.isInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
       const size = stepSize2(stepLevel);
-      assertEx12(
+      assertEx15(
         stepLevel <= blocksMaxStep,
         () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
       );
       const chainContext = await this.getChainContextRead();
-      if (isUndefined3(chainContext.head)) {
+      if (isUndefined4(chainContext.head)) {
         return [];
       }
       const start = stepIndex * size;
@@ -1498,7 +1834,7 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async chainId(blockNumber = "latest") {
     return await this.spanAsync("chainId", async () => {
-      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx12(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
+      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx15(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
     }, this.context);
   }
   async createHandler() {
@@ -1610,7 +1946,7 @@ SimpleBlockViewer = __decorateClass([
 ], SimpleBlockViewer);
 
 // src/simple/chainContractViewer/SimpleChainContractViewer.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
 import { ChainContractViewerMoniker, FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleChainContractViewer = class extends AbstractCreatableProvider {
   moniker = SimpleChainContractViewer.defaultMoniker;
@@ -1627,7 +1963,7 @@ var SimpleChainContractViewer = class extends AbstractCreatableProvider {
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
       while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx13(await contractViewer.forkedChainContractViewer());
+        contractViewer = assertEx16(await contractViewer.forkedChainContractViewer());
         forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
         chainId = await contractViewer.chainId();
       }
@@ -1668,7 +2004,7 @@ SimpleChainContractViewer = __decorateClass([
 ], SimpleChainContractViewer);
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
-import { assertEx as assertEx14 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
   ChainContractViewerMoniker as ChainContractViewerMoniker2,
@@ -1687,374 +2023,72 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
     const context = this.getBlockContextRead();
     this._signedHydratedBlockCache = new HydratedCache(context, async (store, hash, maxDepth, minDepth) => {
       const result = await hydrateBlock(context, hash, maxDepth, minDepth);
-      return asSignedHydratedBlockWithStorageMeta2(result, true);
-    }, 200);
-    return this._signedHydratedBlockCache;
-  }
-  get store() {
-    return this._store;
-  }
-  static async paramsHandler(params) {
-    return {
-      ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx14(params.finalizedArchivist, () => "finalizedArchivist is required")
-    };
-  }
-  chainId() {
-    return this._chainId;
-  }
-  async createHandler() {
-    await super.createHandler();
-    this._chainId = assertEx14(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 = assertEx14(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 assertEx14(block, () => "Could not find current block");
-    }, this.context);
-  }
-  async headBlock() {
-    return (await this.head())[0];
-  }
-  async headHash() {
-    return (await this.headBlock())._hash;
-  }
-  async headNumber() {
-    return (await this.headBlock()).block;
-  }
-  getBlockContextRead() {
-    return {
-      ...this.context,
-      chainMap: this.store.chainMap
-    };
-  }
-  async getChainContextRead() {
-    return {
-      ...this.getBlockContextRead(),
-      head: (await this.head())[0]
-    };
-  }
-  async getCurrentHead() {
-    const chainArchivist = this.finalizedArchivist;
-    const result = assertEx14(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
-    assertEx14(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
-    return result;
-  }
-};
-__publicField(SimpleFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker3);
-__publicField(SimpleFinalizationViewer, "dependencies", [ChainContractViewerMoniker2]);
-__publicField(SimpleFinalizationViewer, "monikers", [FinalizationViewerMoniker3]);
-SimpleFinalizationViewer = __decorateClass([
-  creatableProvider()
-], SimpleFinalizationViewer);
-
-// src/test/buildRandomChain.ts
-import { asAddress as asAddress2, assertEx as assertEx17 } from "@xylabs/sdk-js";
-import {
-  Account as Account3,
-  asSchema as asSchema3,
-  IdSchema as IdSchema2,
-  MemoryArchivist,
-  PayloadBuilder as PayloadBuilder8
-} from "@xyo-network/sdk-js";
-import {
-  asXL1BlockNumber as asXL1BlockNumber9
-} from "@xyo-network/xl1-protocol-lib";
-
-// src/test/buildNextBlock.ts
-import {
-  AttoXL1 as AttoXL12,
-  XYO_STEP_REWARD_ADDRESS as XYO_STEP_REWARD_ADDRESS2
-} from "@xyo-network/xl1-protocol-lib";
-
-// src/test/buildBlock.ts
-import { assertEx as assertEx15, isDefined as isDefined7 } from "@xylabs/sdk-js";
-import {
-  asAnyPayload as asAnyPayload3,
-  BoundWitnessBuilder as BoundWitnessBuilder2,
-  PayloadBuilder as PayloadBuilder4
-} from "@xyo-network/sdk-js";
-import {
-  asXL1BlockNumber as asXL1BlockNumber6,
-  AttoXL1,
-  isBlockBoundWitness,
-  rewardAddressFromStepIdentity,
-  StepRewardFractions,
-  StepSizes as StepSizes6,
-  XL1_PROTOCOL_VERSION,
-  XYO_STEP_REWARD_ADDRESS,
-  XYO_ZERO_ADDRESS
-} from "@xyo-network/xl1-protocol-lib";
-
-// src/test/BuildBlockOptions.ts
-import {
-  isAddress,
-  isArray,
-  isHash as isHash2,
-  isNumber,
-  isObject as isObject2
-} from "@xylabs/sdk-js";
-var isBaseBuildBlockOptions = (value) => {
-  if (!isObject2(value)) {
-    return false;
-  }
-  const typedValue = value;
-  if (!isArray(typedValue.blockPayloads) || !isAddress(typedValue.chainId) || !isArray(typedValue.signers) || !isArray(typedValue.txs)) {
-    return false;
-  }
-  return true;
-};
-var isBuildGenesisBlockOptions = (value) => {
-  if (!isBaseBuildBlockOptions(value)) {
-    return false;
+      return asSignedHydratedBlockWithStorageMeta2(result, true);
+    }, 200);
+    return this._signedHydratedBlockCache;
   }
-  const typedValue = value;
-  if (typedValue.previousBlockHash !== null) {
-    return false;
+  get store() {
+    return this._store;
   }
-  if (typedValue.previousBlockNumber !== void 0) {
-    return false;
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      finalizedArchivist: assertEx17(params.finalizedArchivist, () => "finalizedArchivist is required")
+    };
   }
-  return true;
-};
-var isBuildNextBlockOptions = (value) => {
-  if (!isBaseBuildBlockOptions(value)) {
-    return false;
+  chainId() {
+    return this._chainId;
   }
-  const typedValue = value;
-  if (!isHash2(typedValue.previousBlockHash)) {
-    return false;
+  async createHandler() {
+    await super.createHandler();
+    this._chainId = assertEx17(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => "chain.id is required if empty archivist");
+    this._store = { chainMap: this.params.finalizedArchivist };
   }
-  if (!isNumber(typedValue.previousBlockNumber)) {
-    return false;
+  async head() {
+    return await this.spanAsync("head", async () => {
+      const currentHead = assertEx17(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 assertEx17(block, () => "Could not find current block");
+    }, this.context);
   }
-  if (!isArray(typedValue.previousStepHashes)) {
-    return false;
+  async headBlock() {
+    return (await this.head())[0];
   }
-  return true;
-};
-
-// src/test/buildBlock.ts
-function calculateCompletedStepReward(step, balance) {
-  return AttoXL1(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1]);
-}
-async function buildBlock(options) {
-  const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
-  const blockNumber = asXL1BlockNumber6(previousBlockNumber + 1, true);
-  const inStepHashes = isBuildNextBlockOptions(options) ? options.previousStepHashes : [];
-  const previousBlockHash = isBuildNextBlockOptions(options) ? options.previousBlockHash : void 0;
-  const stepRewardPoolBalance = isBuildNextBlockOptions(options) ? options.stepRewardPoolBalance : AttoXL1(0n);
-  const {
-    chainId,
-    txs,
-    chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS,
-    blockPayloads,
-    protocol = XL1_PROTOCOL_VERSION,
-    signers
-  } = options;
-  const step_hashes = [];
-  for (const [tx] of txs) {
-    if (tx.nbf > blockNumber) {
-      throw new Error(`Transaction ${await PayloadBuilder4.hash(tx)} not valid for block ${blockNumber} - NBF is ${tx.nbf}`);
-    }
-    if (tx.exp < blockNumber) {
-      throw new Error(`Transaction ${await PayloadBuilder4.hash(tx)} not valid for block ${blockNumber} - EXP is ${tx.exp}`);
-    }
+  async headHash() {
+    return (await this.headBlock())._hash;
   }
-  const completedStepRewardTransfers = [];
-  for (const [i, step] of StepSizes6.entries()) {
-    if (blockNumber < step) {
-      break;
-    }
-    if (blockNumber % step === 0) {
-      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress !== XYO_ZERO_ADDRESS) {
-        const completedStepRewardHolderAddress = rewardAddressFromStepIdentity({ block: blockNumber, step });
-        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
-        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }));
-      }
-      step_hashes.push(assertEx15(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
-    } else {
-      if (isDefined7(inStepHashes.at(i))) {
-        step_hashes.push(inStepHashes[i]);
-      }
-    }
+  async headNumber() {
+    return (await this.headBlock()).block;
   }
-  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 BoundWitnessBuilder2().fields({
-    block,
-    chain: chainId,
-    previous,
-    step_hashes,
-    protocol
-  }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder4.addStorageMeta(payloads)).build();
-  assertEx15(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
-  return [await PayloadBuilder4.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload3(p, true))];
-}
-
-// src/test/buildNextBlock.ts
-async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS2, stepRewardPoolBalance = AttoXL12(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,
-    stepRewardPoolBalance
-  });
-}
-
-// src/test/buildRandomGenesisBlock.ts
-import { asAddress, assertEx as assertEx16 } from "@xylabs/sdk-js";
-import {
-  Account as Account2,
-  asAnyPayload as asAnyPayload4,
-  asSchema as asSchema2,
-  IdSchema,
-  PayloadBuilder as PayloadBuilder5
-} from "@xyo-network/sdk-js";
-import {
-  asXL1BlockNumber as asXL1BlockNumber7
-} from "@xyo-network/xl1-protocol-lib";
-
-// src/test/buildGenesisBlock.ts
-import { XYO_ZERO_ADDRESS as XYO_ZERO_ADDRESS2 } from "@xyo-network/xl1-protocol-lib";
-async function buildGenesisBlock(chainId, txs, blockPayloads, signers, chainStepRewardAddress = XYO_ZERO_ADDRESS2, protocol) {
-  return await buildBlock({
-    previousBlockHash: null,
-    chainId,
-    txs,
-    blockPayloads,
-    signers,
-    chainStepRewardAddress,
-    protocol
-  });
-}
-
-// src/test/buildRandomGenesisBlock.ts
-var TestChainId = assertEx16(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
-
-// src/test/createGenesisBlock.ts
-import { PayloadBuilder as PayloadBuilder7 } 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 PayloadBuilder6 } from "@xyo-network/sdk-js";
-import {
-  asXL1BlockNumber as asXL1BlockNumber8,
-  ChainStakeIntentSchema,
-  defaultTransactionFees as defaultTransactionFees2
-} from "@xyo-network/xl1-protocol-lib";
-async function createProducerChainStakeIntent(from, exp, nbf = 0) {
-  return await PayloadBuilder6.addHashMeta(new PayloadBuilder6({ schema: ChainStakeIntentSchema }).fields({
-    from,
-    exp,
-    nbf,
-    intent: "producer"
-  }).build());
-}
-
-// src/test/createGenesisBlock.ts
-var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genesisBlockRewardAmount, genesisBlockRewardAddress) => {
-  const blockPayloads = await PayloadBuilder7.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 PayloadBuilder7.addHashMeta(createTransferPayload(
-      nextContractAddress,
-      { [genesisBlockRewardAddress]: genesisBlockRewardAmount }
-    )));
+  getBlockContextRead() {
+    return {
+      ...this.context,
+      chainMap: this.store.chainMap
+    };
   }
-  return await buildGenesisBlock(nextContractAddress, [], blockPayloads, [initialBlockProducer]);
-};
-
-// src/test/buildRandomChain.ts
-var TestGenesisBlockRewardAddress = assertEx17(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 Account3.random();
-  if (!lastBlock) {
-    const block = await createGenesisBlock(
-      blockProducer,
-      chainIdToUse,
-      1000000000n * 10n ** 18n,
-      transactionAccountToUse.address
-    );
-    blocks.push(block);
-    remaining = remaining - 1;
-    lastBlock = block;
+  async getChainContextRead() {
+    return {
+      ...this.getBlockContextRead(),
+      head: (await this.head())[0]
+    };
   }
-  const resolvedReceiverAddresses = receiverAddresses ?? [(await Account3.random()).address];
-  let saltCounter = 0;
-  while (remaining > 0) {
-    saltCounter += 1;
-    const payloads = [new PayloadBuilder8({ schema: IdSchema2 }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()];
-    saltCounter += 1;
-    const additionalPrivatePayloads = remaining % 2 === 0 ? [new PayloadBuilder8({ schema: asSchema3("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,
-        asXL1BlockNumber9(Math.max(count - remaining - 1e3, 0), true),
-        asXL1BlockNumber9(count - remaining + 1e3, true),
-        [asSchema3("network.xyo.private", true)],
-        receiverAddress
-      ));
-    }
-    const previousBlock2 = assertEx17(lastBlock?.[0], () => new Error("No last block"));
-    const block = await buildNextBlock(previousBlock2, txs, [], [blockProducer], transactionAccountToUse.address);
-    blocks.push(block);
-    remaining = remaining - 1;
-    lastBlock = block;
+  async getCurrentHead() {
+    const chainArchivist = this.finalizedArchivist;
+    const result = assertEx17(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
+    assertEx17(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
+    return result;
   }
-  return blocks;
 };
-async function buildRandomChainArchivist(count = 20) {
-  const producerAccount = await Account3.random();
-  const blocks = await buildRandomChain(producerAccount, count);
-  const archivist = await MemoryArchivist.create();
-  const payloads = flattenHydratedBlocks(blocks);
-  await archivist.insert(payloads);
-  return archivist;
-}
+__publicField(SimpleFinalizationViewer, "defaultMoniker", FinalizationViewerMoniker3);
+__publicField(SimpleFinalizationViewer, "dependencies", [ChainContractViewerMoniker2]);
+__publicField(SimpleFinalizationViewer, "monikers", [FinalizationViewerMoniker3]);
+SimpleFinalizationViewer = __decorateClass([
+  creatableProvider()
+], SimpleFinalizationViewer);
 
 // src/test/getSimpleBlockViewerLocator.ts
 async function getTestSimpleBlockViewerLocator({
@@ -2083,6 +2117,9 @@ function getTestProviderContext2(config) {
   return getTestProviderContext(config);
 }
 export {
+  TestGenesisBlockRewardAddress,
+  buildRandomChain,
+  buildRandomChainArchivist,
   buildRandomTransaction,
   getTestProviderContext2 as getTestProviderContext,
   getTestSimpleBlockViewerLocator