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

package/dist/neutral/test/index.mjs

@@ -889,91 +889,12 @@ var findEndBlockRecursive = async (viewer, startBlock, targetTimeMs, estimatedBl
 
 // src/ChainContextHelpers.ts
 import {
-  isDefined as isDefined6,
+  isDefined as isDefined5,
   isObject,
   isUndefined as isUndefined2,
   timeBudget
 } from "@xylabs/sdk-js";
-
-// src/driver/cache/LruCacheMap.ts
-import { LRUCache } from "lru-cache";
-var LruCacheMap = class {
-  lruCache;
-  constructor(options) {
-    this.lruCache = new LRUCache(options ?? { max: 5e3 });
-  }
-  clear() {
-    this.lruCache.clear();
-  }
-  delete(id) {
-    return this.lruCache.delete(id);
-  }
-  get(id) {
-    return this.lruCache.get(id);
-  }
-  getMany(id) {
-    const results = [];
-    for (const key of id) {
-      const value = this.lruCache.get(key);
-      if (value !== void 0) {
-        results.push(value);
-      }
-    }
-    return results;
-  }
-  has(id) {
-    return this.lruCache.has(id);
-  }
-  set(id, data) {
-    this.lruCache.set(id, data);
-  }
-  setMany(entries) {
-    for (const [key, value] of entries) {
-      this.lruCache.set(key, value);
-    }
-  }
-};
-
-// src/driver/memory/MemoryMap.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-var MemoryMap = class {
-  map;
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-  }
-  clear() {
-    this.map.clear();
-  }
-  delete(id) {
-    return this.map.delete(id);
-  }
-  get(id) {
-    return this.map.get(id);
-  }
-  getMany(ids) {
-    const results = [];
-    for (const id of ids) {
-      const data = this.map.get(id);
-      if (isDefined5(data)) {
-        results.push(data);
-      }
-    }
-    return results;
-  }
-  has(id) {
-    return this.map.has(id);
-  }
-  set(id, data) {
-    this.map.set(id, data);
-  }
-  setMany(entries) {
-    for (const [key, value] of entries) {
-      this.map.set(key, value);
-    }
-  }
-};
-
-// src/ChainContextHelpers.ts
+import { LruCacheMap, MemoryMap } from "@xyo-network/xl1-driver-memory";
 function contextCache(context, name, create) {
   if (!isObject(context.caches)) {
     throw new Error("Context does not have an appropriate caches property");
@@ -991,7 +912,7 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4 }
   );
   const { timeBudgetLimit = 0 } = context;
   const cacheResult = await cache.get(key);
-  if (isDefined6(cacheResult)) {
+  if (isDefined5(cacheResult)) {
     return cacheResult;
   }
   const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func();
@@ -1049,7 +970,7 @@ var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
 // src/block/primitives/blockFromBlockNumber.ts
 import {
   asHash,
-  isDefined as isDefined7,
+  isDefined as isDefined6,
   spanAsync
 } from "@xylabs/sdk-js";
 import { toSafeJsonString } from "@xylabs/sdk-js";
@@ -1064,7 +985,7 @@ async function blockFromBlockNumber(context, blockNumber) {
     const { chainMap, head } = context;
     return await withContextCacheResponse(context, "blockFromBlockNumber", cacheKey, async () => {
       const [result] = await chainMap.get([head._hash]);
-      if (!isDefined7(result)) {
+      if (!isDefined6(result)) {
         throw new Error(`Head block not found for hash: ${head._hash}`);
       }
       let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
@@ -1077,8 +998,8 @@ async function blockFromBlockNumber(context, blockNumber) {
       while (currentBlock.block > blockNumber) {
         let jumpHash = currentBlock.previous;
         let jumpBlockNumber = currentBlock.block - 1;
-        for (const [step, stepSize] of StepSizes2.entries()) {
-          const possibleJumpBlockNumber = currentBlock.block - currentBlock.block % stepSize - 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}`);
@@ -1087,7 +1008,7 @@ async function blockFromBlockNumber(context, blockNumber) {
         const [newBlock] = await chainMap.get([
           asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`)
         ]);
-        if (!isDefined7(newBlock)) {
+        if (!isDefined6(newBlock)) {
           throw new Error(`Block not found for jump hash: ${jumpHash}`);
         }
         currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
@@ -1109,6 +1030,53 @@ async function blockFromBlockNumber(context, blockNumber) {
   }, { ...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;
+  }
+  for (const range2 of remaining) {
+    for (let i = range2[0]; i <= range2[1]; i++) {
+      fitted.push([i, i]);
+    }
+  }
+  return fitted.toSorted((a, b) => a[0] - b[0]);
+}
+
 // src/block/primitives/validateTransactionOpcodes.ts
 import {
   assertEx as assertEx9,
@@ -1278,22 +1246,106 @@ var ConfigZod = z18.extend(BaseConfigZod, {
   })
 }).check(z18.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,
+  isPayloadOfSchemaType,
+  isStorageMeta
+} from "@xyo-network/sdk-js";
+var BlocksStepSummarySchema = asSchema("network.xyo.step.summary.blocks", true);
+var isBlocksStepSummary = isPayloadOfSchemaType(BlocksStepSummarySchema);
+var asBlocksStepSummary = AsObjectFactory.create(isBlocksStepSummary);
+var isBlocksStepSummaryWithStorageMeta = (value) => {
+  return isBlocksStepSummary(value) && isStorageMeta(value);
+};
+var asBlocksStepSummaryWithStorageMeta = AsObjectFactory.create(isBlocksStepSummaryWithStorageMeta);
+
+// src/summary/primitives/blocks/blocksMaxStep.ts
+var blocksMaxStep = 3;
+
+// src/summary/primitives/blocks/blocksStepSummaryFromRange.ts
+import { assertEx as assertEx11, 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";
+function blocksStepSummaryKey(frameHeadHash, frameSize) {
+  return `${frameHeadHash}|${frameSize}`;
+}
+async function blocksStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
+  const cacheKey = `${range[0]}|${range[1]}`;
+  return await withContextCacheResponse(context, "blocksStepSummaryFromRange", cacheKey, async () => {
+    return await spanRootAsync("blocksStepSummaryFromRange", async () => {
+      const frameHead = assertEx11(
+        await blockViewer.blockByNumber(range[1]),
+        () => `Block not found for number: ${range[1]}`
+      );
+      const frameHeadHash = frameHead[0]._hash;
+      const frameSize = range[1] - range[0] + 1;
+      let result;
+      if (frameSize === 1) {
+        result = {
+          schema: BlocksStepSummarySchema,
+          hash: frameHeadHash,
+          stepSize: -1,
+          blocks: [frameHead]
+        };
+      } else {
+        const step = StepSizes4.indexOf(asXL1BlockNumber4(frameSize, true));
+        assertEx11(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes4.join(", ")}`);
+        const key = blocksStepSummaryKey(frameHeadHash, frameSize);
+        const summaryResult = await summaryMap.get(key);
+        if (isAnyPayload(summaryResult)) {
+          result = asBlocksStepSummary(summaryResult, { required: true });
+        } else {
+          await semaphores[step].acquire();
+          try {
+            const subRanges = deepCalculateFramesFromRange(range, step - 1);
+            const subResults = await Promise.all(subRanges.map((subRange) => blocksStepSummaryFromRange(
+              context,
+              semaphores,
+              blockViewer,
+              summaryMap,
+              subRange
+            )));
+            const blocks = subResults.flatMap((subResult) => subResult.blocks);
+            result = {
+              schema: BlocksStepSummarySchema,
+              hash: frameHeadHash,
+              stepSize: frameSize,
+              blocks
+            };
+            await summaryMap.set(key, result);
+          } finally {
+            semaphores[step].release();
+          }
+        }
+      }
+      return result;
+    }, { ...context, timeBudgetLimit: 500 });
+  }, { max: 1e5 });
+}
+
 // src/simple/block/SimpleBlockViewer.ts
 import {
-  assertEx as assertEx11,
+  assertEx as assertEx12,
   exists,
   isUndefined as isUndefined3
 } from "@xylabs/sdk-js";
+import { LruCacheMap as LruCacheMap2 } from "@xyo-network/xl1-driver-memory";
 import {
   asSignedHydratedBlockWithHashMeta,
   asSignedHydratedBlockWithStorageMeta,
-  asXL1BlockNumber as asXL1BlockNumber3,
+  asXL1BlockNumber as asXL1BlockNumber5,
+  asXL1BlockRange as asXL1BlockRange4,
   BlockViewerMoniker,
-  FinalizationViewerMoniker
+  FinalizationViewerMoniker,
+  stepSize as stepSize2,
+  StepSizes as StepSizes5
 } from "@xyo-network/xl1-protocol-lib";
+import { Semaphore } from "async-mutex";
 
 // src/utils/HydratedCache.ts
-import { LRUCache as LRUCache2 } from "lru-cache";
+import { LRUCache } from "lru-cache";
 var HydratedCache = class {
   cache;
   context;
@@ -1301,7 +1353,7 @@ var HydratedCache = class {
   constructor(context, hydrateFunction, maxCount = 2e3, ttl = Number.MAX_SAFE_INTEGER) {
     this.context = context;
     this.hydrateFunction = hydrateFunction;
-    this.cache = new LRUCache2({ max: maxCount, ttl });
+    this.cache = new LRUCache({ max: maxCount, ttl });
   }
   async get(hash) {
     const existing = this.cache.get(hash);
@@ -1321,8 +1373,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   moniker = SimpleBlockViewer.defaultMoniker;
   _store;
   finalizationViewer;
-  payloadCache = new LruCacheMap({ max: 1e4 });
-  signedHydratedBlockWithHashMetaCache = new LruCacheMap({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  payloadCache = new LruCacheMap2({ max: 1e4 });
+  signedHydratedBlockWithHashMetaCache = new LruCacheMap2({ max: 2e3, ttl: 1e3 * 60 * 60 });
+  _blockStepSemaphores = StepSizes5.map(() => new Semaphore(20));
+  _blocksSummaryMap;
   _headPollHash;
   _headPollInProgress = false;
   _headPollTimer = null;
@@ -1330,6 +1384,10 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   get finalizedArchivist() {
     return this.params.finalizedArchivist;
   }
+  get blocksSummaryMap() {
+    this._blocksSummaryMap ??= this.params.blocksSummaryMap ?? new LruCacheMap2({ max: 32 });
+    return this._blocksSummaryMap;
+  }
   get headPollIntervalMs() {
     return this.params.headPollIntervalMs;
   }
@@ -1348,11 +1406,12 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     const headPollIntervalMs = params.headPollIntervalMs;
     if (headPollIntervalMs !== void 0) {
-      assertEx11(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
+      assertEx12(headPollIntervalMs >= MIN_HEAD_POLL_INTERVAL_MS, () => `headPollIntervalMs must be at least ${MIN_HEAD_POLL_INTERVAL_MS}ms`);
     }
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx11(params.finalizedArchivist, () => "finalizedArchivist is required"),
+      blocksSummaryMap: params.blocksSummaryMap,
+      finalizedArchivist: assertEx12(params.finalizedArchivist, () => "finalizedArchivist is required"),
       headPollIntervalMs
     };
   }
@@ -1381,8 +1440,8 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByHash(hash, limit = 50) {
     return await this.spanAsync("blocksByHash", async () => {
-      assertEx11(limit > 0, () => "limit must be greater than 0");
-      assertEx11(limit <= 100, () => "limit must be less than 100");
+      assertEx12(limit > 0, () => "limit must be greater than 0");
+      assertEx12(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -1396,8 +1455,8 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
   }
   async blocksByNumber(blockNumber, limit = 50) {
     return await this.spanAsync("blocksByNumber", async () => {
-      assertEx11(limit > 0, () => "limit must be greater than 0");
-      assertEx11(limit <= 100, () => "limit must be less than 100");
+      assertEx12(limit > 0, () => "limit must be greater than 0");
+      assertEx12(limit <= 100, () => "limit must be less than 100");
       const chainContext = await this.getChainContextRead();
       if (isUndefined3(chainContext.head)) {
         return [];
@@ -1407,15 +1466,39 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
       while (current && blocks.length < limit) {
         blocks.push(current);
         if (current[0].block === 0) break;
-        const previousNumber = asXL1BlockNumber3(current[0].block - 1, true);
+        const previousNumber = asXL1BlockNumber5(current[0].block - 1, true);
         current = await this.blockByNumberWithContext(chainContext, previousNumber);
       }
       return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
     }, this.context);
   }
+  async blocksByStep(stepLevel, stepIndex) {
+    return await this.spanAsync("blocksByStep", async () => {
+      assertEx12(Number.isInteger(stepIndex) && stepIndex >= 0, () => "stepIndex must be a non-negative integer");
+      const size = stepSize2(stepLevel);
+      assertEx12(
+        stepLevel <= blocksMaxStep,
+        () => `blocksByStep does not support step levels above ${blocksMaxStep} (requested ${stepLevel})`
+      );
+      const chainContext = await this.getChainContextRead();
+      if (isUndefined3(chainContext.head)) {
+        return [];
+      }
+      const start = stepIndex * size;
+      const end = Math.min(start + size - 1, chainContext.head.block);
+      if (end < start) {
+        return [];
+      }
+      const range = asXL1BlockRange4([start, end], { name: "blocksByStep" });
+      const frames = deepCalculateFramesFromRange(range, blocksMaxStep);
+      const summaries = await Promise.all(frames.map((frame) => blocksStepSummaryFromRange(this.context, this._blockStepSemaphores, this, this.blocksSummaryMap, frame)));
+      const blocks = summaries.flatMap((summary) => summary.blocks);
+      return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true)).toReversed();
+    }, this.context);
+  }
   async chainId(blockNumber = "latest") {
     return await this.spanAsync("chainId", async () => {
-      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx11(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
+      return blockNumber === "latest" ? (await this.finalizationViewer.headBlock()).chain : assertEx12(await this.blockByNumber(blockNumber), () => `Block not found [${blockNumber}]`)[0].chain;
     }, this.context);
   }
   async createHandler() {
@@ -1443,9 +1526,9 @@ var SimpleBlockViewer = class extends AbstractCreatableProvider {
     remainingHashes = remainingHashes.filter((h) => !cachedHashes.has(h));
     const finalizedPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
     const resultPayloads = [...cachedPayloads, ...finalizedPayloads.filter(exists)];
-    resultPayloads.map((payload) => {
+    for (const payload of resultPayloads) {
       this.payloadCache.set(payload._hash, payload);
-    });
+    }
     return resultPayloads;
   }
   async rate(range, timeUnit) {
@@ -1527,7 +1610,7 @@ SimpleBlockViewer = __decorateClass([
 ], SimpleBlockViewer);
 
 // src/simple/chainContractViewer/SimpleChainContractViewer.ts
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
 import { ChainContractViewerMoniker, FinalizationViewerMoniker as FinalizationViewerMoniker2 } from "@xyo-network/xl1-protocol-lib";
 var SimpleChainContractViewer = class extends AbstractCreatableProvider {
   moniker = SimpleChainContractViewer.defaultMoniker;
@@ -1544,7 +1627,7 @@ var SimpleChainContractViewer = class extends AbstractCreatableProvider {
       let contractViewer = this;
       let forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
       while (forkedAtBlockNumber !== null && blockNumber <= forkedAtBlockNumber) {
-        contractViewer = assertEx12(await contractViewer.forkedChainContractViewer());
+        contractViewer = assertEx13(await contractViewer.forkedChainContractViewer());
         forkedAtBlockNumber = await contractViewer.forkedAtBlockNumber();
         chainId = await contractViewer.chainId();
       }
@@ -1585,7 +1668,7 @@ SimpleChainContractViewer = __decorateClass([
 ], SimpleChainContractViewer);
 
 // src/simple/finalization/SimpleFinalizationViewer.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14 } from "@xylabs/sdk-js";
 import {
   asSignedHydratedBlockWithStorageMeta as asSignedHydratedBlockWithStorageMeta2,
   ChainContractViewerMoniker as ChainContractViewerMoniker2,
@@ -1614,7 +1697,7 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx13(params.finalizedArchivist, () => "finalizedArchivist is required")
+      finalizedArchivist: assertEx14(params.finalizedArchivist, () => "finalizedArchivist is required")
     };
   }
   chainId() {
@@ -1622,18 +1705,18 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._chainId = assertEx13(this.config.chain.id ?? (await findMostRecentBlock(this.params.finalizedArchivist))?.chain, () => "chain.id is required if empty archivist");
+    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 = assertEx13(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      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 assertEx13(block, () => "Could not find current block");
+      return assertEx14(block, () => "Could not find current block");
     }, this.context);
   }
   async headBlock() {
@@ -1659,8 +1742,8 @@ var SimpleFinalizationViewer = class extends AbstractCreatableProvider {
   }
   async getCurrentHead() {
     const chainArchivist = this.finalizedArchivist;
-    const result = assertEx13(await findMostRecentBlock(chainArchivist), () => "Could not find most recent block [getCurrentHead]");
-    assertEx13(result?.chain === this._chainId, () => "Chain ID does not match head block chain ID");
+    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;
   }
 };
@@ -1672,16 +1755,16 @@ SimpleFinalizationViewer = __decorateClass([
 ], SimpleFinalizationViewer);
 
 // src/test/buildRandomChain.ts
-import { asAddress as asAddress2, assertEx as assertEx16 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx17 } from "@xylabs/sdk-js";
 import {
   Account as Account3,
-  asSchema as asSchema2,
+  asSchema as asSchema3,
   IdSchema as IdSchema2,
   MemoryArchivist,
   PayloadBuilder as PayloadBuilder8
 } from "@xyo-network/sdk-js";
 import {
-  asXL1BlockNumber as asXL1BlockNumber7
+  asXL1BlockNumber as asXL1BlockNumber9
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildNextBlock.ts
@@ -1691,19 +1774,19 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildBlock.ts
-import { assertEx as assertEx14, isDefined as isDefined8 } from "@xylabs/sdk-js";
+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 asXL1BlockNumber4,
+  asXL1BlockNumber as asXL1BlockNumber6,
   AttoXL1,
   isBlockBoundWitness,
   rewardAddressFromStepIdentity,
   StepRewardFractions,
-  StepSizes as StepSizes3,
+  StepSizes as StepSizes6,
   XL1_PROTOCOL_VERSION,
   XYO_STEP_REWARD_ADDRESS,
   XYO_ZERO_ADDRESS
@@ -1763,7 +1846,7 @@ function calculateCompletedStepReward(step, balance) {
 }
 async function buildBlock(options) {
   const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber;
-  const blockNumber = asXL1BlockNumber4(previousBlockNumber + 1, true);
+  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);
@@ -1785,7 +1868,7 @@ async function buildBlock(options) {
     }
   }
   const completedStepRewardTransfers = [];
-  for (const [i, step] of StepSizes3.entries()) {
+  for (const [i, step] of StepSizes6.entries()) {
     if (blockNumber < step) {
       break;
     }
@@ -1795,9 +1878,9 @@ async function buildBlock(options) {
         const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance);
         completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }));
       }
-      step_hashes.push(assertEx14(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
+      step_hashes.push(assertEx15(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`));
     } else {
-      if (isDefined8(inStepHashes.at(i))) {
+      if (isDefined7(inStepHashes.at(i))) {
         step_hashes.push(inStepHashes[i]);
       }
     }
@@ -1818,7 +1901,7 @@ async function buildBlock(options) {
     step_hashes,
     protocol
   }).meta({ $epoch: Date.now(), $signatures: [] }).signers(signers).payloads(await PayloadBuilder4.addStorageMeta(payloads)).build();
-  assertEx14(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
+  assertEx15(isBlockBoundWitness(bw), () => "Build of BlockBoundWitness failed");
   return [await PayloadBuilder4.addStorageMeta(bw), txPayloads.map((p) => asAnyPayload3(p, true))];
 }
 
@@ -1839,16 +1922,16 @@ async function buildNextBlock(previousBlock, txs, blockPayloads, signers, chainS
 }
 
 // src/test/buildRandomGenesisBlock.ts
-import { asAddress, assertEx as assertEx15 } from "@xylabs/sdk-js";
+import { asAddress, assertEx as assertEx16 } from "@xylabs/sdk-js";
 import {
   Account as Account2,
   asAnyPayload as asAnyPayload4,
-  asSchema,
+  asSchema as asSchema2,
   IdSchema,
   PayloadBuilder as PayloadBuilder5
 } from "@xyo-network/sdk-js";
 import {
-  asXL1BlockNumber as asXL1BlockNumber5
+  asXL1BlockNumber as asXL1BlockNumber7
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/test/buildGenesisBlock.ts
@@ -1866,7 +1949,7 @@ async function buildGenesisBlock(chainId, txs, blockPayloads, signers, chainStep
 }
 
 // src/test/buildRandomGenesisBlock.ts
-var TestChainId = assertEx15(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
+var TestChainId = assertEx16(asAddress("c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44"));
 
 // src/test/createGenesisBlock.ts
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
@@ -1883,7 +1966,7 @@ import {
 // src/test/createProducerChainStakeIntentTransaction.ts
 import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
 import {
-  asXL1BlockNumber as asXL1BlockNumber6,
+  asXL1BlockNumber as asXL1BlockNumber8,
   ChainStakeIntentSchema,
   defaultTransactionFees as defaultTransactionFees2
 } from "@xyo-network/xl1-protocol-lib";
@@ -1919,7 +2002,7 @@ var createGenesisBlock = async (initialBlockProducer, nextContractAddress, genes
 };
 
 // src/test/buildRandomChain.ts
-var TestGenesisBlockRewardAddress = assertEx16(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
+var TestGenesisBlockRewardAddress = assertEx17(asAddress2("fa7f0bb865a4bfff3d5e2c726d3e063297014da9"));
 var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId, transactionAccount, receiverAddresses) => {
   const chainIdToUse = chainId ?? TestChainId;
   const blocks = [];
@@ -1943,20 +2026,20 @@ var buildRandomChain = async (blockProducer, count = 10, previousBlock, chainId,
     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 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,
-        asXL1BlockNumber7(Math.max(count - remaining - 1e3, 0), true),
-        asXL1BlockNumber7(count - remaining + 1e3, true),
-        [asSchema2("network.xyo.private", true)],
+        asXL1BlockNumber9(Math.max(count - remaining - 1e3, 0), true),
+        asXL1BlockNumber9(count - remaining + 1e3, true),
+        [asSchema3("network.xyo.private", true)],
         receiverAddress
       ));
     }
-    const previousBlock2 = assertEx16(lastBlock?.[0], () => new Error("No last block"));
+    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;