@xyo-network/xl1-protocol-sdk 1.18.0-rc.1 → 1.18.0

package/dist/neutral/index.mjs

@@ -234,6 +234,30 @@ function blockRangeSteps(range, steps) {
 }
 __name(blockRangeSteps, "blockRangeSteps");
 
+// src/primitives/chain/getWindowedChain.ts
+async function getWindowedChain(blockViewer, maxWindowSize, previousChain = []) {
+  const newBlocks = [];
+  let currentBlock = await blockViewer.currentBlock();
+  console.log("[getWindowedChain] Current Block:", currentBlock?.[0]._hash);
+  const head = currentBlock;
+  while (currentBlock !== null && currentBlock[0].block >= head[0].block) {
+    newBlocks.unshift(currentBlock);
+    const previousBlockHash = currentBlock[0].previous;
+    currentBlock = previousBlockHash === null ? null : await blockViewer.blockByHash(previousBlockHash);
+  }
+  const newChain = [
+    ...previousChain,
+    ...newBlocks
+  ].slice(-maxWindowSize);
+  while (newChain.length > 0 && newChain.length < maxWindowSize && newChain[0][0].previous !== null) {
+    const block = await blockViewer.blockByHash(newChain[0][0].previous);
+    if (block === null) break;
+    newChain.unshift(block);
+  }
+  return newChain;
+}
+__name(getWindowedChain, "getWindowedChain");
+
 // src/primitives/chain/step/chainStepRewardAddress.ts
 import { assertEx as assertEx7, exists, toAddress as toAddress4 } from "@xylabs/sdk-js";
 import { asTransfer, isTransfer, XYO_STEP_REWARD_ADDRESS } from "@xyo-network/xl1-protocol";
@@ -921,6 +945,83 @@ function elevatedPayloads([tx, payloads]) {
 }
 __name(elevatedPayloads, "elevatedPayloads");
 
+// src/primitives/uncle/scoreUncle.ts
+function scoreUncle(finalizedWindowedChain, blocks) {
+  return blocks.length;
+}
+__name(scoreUncle, "scoreUncle");
+
+// src/primitives/uncle/findBestUncle.ts
+function findBestUncle(finalizedWindowedChain, uncles) {
+  const scores = uncles.map((uncle) => [
+    scoreUncle(finalizedWindowedChain, uncle),
+    uncle
+  ]).toSorted((a, b) => b[0] - a[0]);
+  return scores[0]?.[1] ?? finalizedWindowedChain;
+}
+__name(findBestUncle, "findBestUncle");
+
+// src/primitives/uncle/findUncles.ts
+import { assertEx as assertEx10, exists as exists2 } from "@xylabs/sdk-js";
+import { isTransactionBoundWitness as isTransactionBoundWitness2 } from "@xyo-network/xl1-protocol";
+function blocksToChains(blocks) {
+  const chains = [];
+  const map = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    map.set(block[0]._hash, block);
+  }
+  for (const block of blocks) {
+    let uncle = [
+      block
+    ];
+    let previous = block[0].previous ? map.get(block[0].previous) : void 0;
+    while (previous) {
+      if (previous[0].block === uncle[0][0].block - 1) {
+        uncle.unshift(previous);
+        previous = previous[0].previous ? map.get(previous[0].previous) : void 0;
+      } else {
+        uncle = [];
+        break;
+      }
+    }
+    if (uncle.length > 0) {
+      chains.push(uncle);
+    }
+  }
+  return chains;
+}
+__name(blocksToChains, "blocksToChains");
+function toValidUncle(_context, finalizedWindowedChain, possibleUncle) {
+  const finalizedWindowStartBlockNumber = finalizedWindowedChain.at(0)?.[0].block ?? -1;
+  const finalizedHead = assertEx10(finalizedWindowedChain.at(-1), () => "finalizedWindowedChain is empty");
+  const prunedPossibleUncle = possibleUncle.filter((b) => b[0].block > finalizedHead[0].block);
+  if (prunedPossibleUncle.length === 0) {
+    return;
+  }
+  if (prunedPossibleUncle[0][0].block !== finalizedHead[0].block + 1) {
+    return;
+  }
+  if (prunedPossibleUncle[0][0].previous !== finalizedHead[0]._hash) {
+    return;
+  }
+  const allUncleTransactions = prunedPossibleUncle.flatMap((b) => b[1]).filter(isTransactionBoundWitness2);
+  const allFinalizedTransactions = finalizedWindowedChain.flatMap((b) => b[1]).filter(isTransactionBoundWitness2);
+  const txPossiblyBeforeWindow = allUncleTransactions.find((tx) => tx.nbf < finalizedWindowStartBlockNumber);
+  if (txPossiblyBeforeWindow) {
+    return;
+  }
+  const txExistsInWindow = allUncleTransactions.find((tx) => allFinalizedTransactions.find((finalTx) => finalTx._hash === tx._hash));
+  if (txExistsInWindow) {
+    return;
+  }
+  return prunedPossibleUncle;
+}
+__name(toValidUncle, "toValidUncle");
+function findUncles(context, finalizedWindowedChain, blocks) {
+  return blocksToChains(blocks).map((chain) => toValidUncle(context, finalizedWindowedChain, chain)).filter(exists2);
+}
+__name(findUncles, "findUncles");
+
 // src/model/ChainContext/ChainContext.ts
 function contextCache(context, name, create) {
   if (!context.caches) {
@@ -946,6 +1047,44 @@ async function withContextCacheResponse(context, name, key, func, { max = 1e4, t
 }
 __name(withContextCacheResponse, "withContextCacheResponse");
 
+// src/model/ChainQualification.ts
+import { HashZod } from "@xylabs/hex";
+import { zodIsFactory } from "@xylabs/zod";
+import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
+import z from "zod";
+var ChainQualificationZod = z.object({
+  head: HashZod,
+  range: XL1BlockRangeZod
+});
+var isChainQualification = zodIsFactory(ChainQualificationZod);
+var ChainQualifiedRangeConfigZod = z.object({
+  range: XL1BlockRangeZod
+});
+var isChainQualifiedRangeConfig = zodIsFactory(ChainQualifiedRangeConfigZod);
+var ChainQualifiedHeadConfigZod = z.object({
+  head: HashZod
+});
+var isChainQualifiedHeadConfig = zodIsFactory(ChainQualifiedHeadConfigZod);
+var ChainQualifiedConfigZod = z.union([
+  ChainQualifiedRangeConfigZod,
+  ChainQualifiedHeadConfigZod,
+  z.object({})
+]);
+var isChainQualifiedConfig = zodIsFactory(ChainQualifiedConfigZod);
+var ExtendChainQualifiedConfigZod = /* @__PURE__ */ __name((zodType) => {
+  return z.union([
+    ChainQualifiedRangeConfigZod.extend(zodType),
+    ChainQualifiedHeadConfigZod.extend(zodType),
+    zodType
+  ]);
+}, "ExtendChainQualifiedConfigZod");
+var ChainQualifiedZod = /* @__PURE__ */ __name((zodType) => {
+  return z.tuple([
+    zodType,
+    ChainQualificationZod
+  ]);
+}, "ChainQualifiedZod");
+
 // src/model/PayloadBundle/bundledPayloadToHydratedBlock.ts
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { asSignedBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
@@ -1019,7 +1158,7 @@ function createTransferPayload(from, transfers, context) {
 __name(createTransferPayload, "createTransferPayload");
 
 // src/transaction/buildTransaction.ts
-import { assertEx as assertEx10, toHex as toHex2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, toHex as toHex2 } from "@xylabs/sdk-js";
 import { BoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
 import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
 import { defaultTransactionFees } from "@xyo-network/xl1-protocol";
@@ -1045,7 +1184,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
   }
   const fields = {
     ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx10(signer.at(0)?.address) : signer.address)
+    from: from ?? (Array.isArray(signer) ? assertEx11(signer.at(0)?.address) : signer.address)
   };
   if (script.length > 0) {
     fields.script = script;
@@ -1153,7 +1292,7 @@ var confirmSubmittedTransaction = /* @__PURE__ */ __name(async (viewer, txHash,
 }, "confirmSubmittedTransaction");
 
 // src/transaction/hydrateTransaction.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from "@xyo-network/archivist-model";
 import { asSignedHydratedTransaction, isAllowedBlockPayload as isAllowedBlockPayload3, isSignedTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
 var tryHydrateTransaction = /* @__PURE__ */ __name(async ({ chainMap }, hash) => {
@@ -1221,7 +1360,7 @@ var tryHydrateElevatedTransaction = /* @__PURE__ */ __name(async ({ chainMap },
   return void 0;
 }, "tryHydrateElevatedTransaction");
 var hydrateElevatedTransaction = /* @__PURE__ */ __name(async (context, hash) => {
-  return assertEx11(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
+  return assertEx12(await tryHydrateElevatedTransaction(context, hash), () => "Hydration failed");
 }, "hydrateElevatedTransaction");
 
 // src/transaction/primitives/transactionBlockByteCount.ts
@@ -1287,7 +1426,7 @@ __name(transactionRequiredGas, "transactionRequiredGas");
 
 // src/transaction/script.ts
 import { asHash as asHash2 } from "@xylabs/sdk-js";
-import { assertEx as assertEx12, filterAs } from "@xylabs/sdk-js";
+import { assertEx as assertEx13, filterAs } from "@xylabs/sdk-js";
 import { isAllowedBlockPayloadWithHashMeta } from "@xyo-network/xl1-protocol";
 var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
@@ -1296,7 +1435,7 @@ var tryExtractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
 var extractElevatedHashesFromScript = /* @__PURE__ */ __name((strings) => {
   const hashes = strings.filter((str) => str.startsWith("elevate|")).map((str) => str.split("|")[1]);
   const filtered = filterAs(hashes, (h) => asHash2(h));
-  assertEx12(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx13(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashesFromScript");
 var tryExtractElevatedHashes = /* @__PURE__ */ __name((tx) => {
@@ -1310,15 +1449,15 @@ var extractElevatedHashes = /* @__PURE__ */ __name((tx) => {
   const { script } = bw;
   const hashes = script ? tryExtractElevatedHashesFromScript(script) : [];
   const filtered = payloads.filter((p) => hashes.includes(p._hash)).filter(isAllowedBlockPayloadWithHashMeta);
-  assertEx12(filtered.length === hashes.length, () => "Invalid elevated hashes");
+  assertEx13(filtered.length === hashes.length, () => "Invalid elevated hashes");
   return filtered;
 }, "extractElevatedHashes");
 
 // src/transaction/signTransaction.ts
-import { assertEx as assertEx13, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
+import { assertEx as assertEx14, hexFromArrayBuffer, toArrayBuffer } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 async function signTransaction(tx, account) {
-  assertEx13(tx.from === account.address, () => "Signer address does not match transaction from address");
+  assertEx14(tx.from === account.address, () => "Signer address does not match transaction from address");
   const unsignedTx = structuredClone(tx);
   unsignedTx.addresses = [
     account.address
@@ -1340,7 +1479,7 @@ async function signTransaction(tx, account) {
 __name(signTransaction, "signTransaction");
 
 // src/transaction/TransactionBuilder.ts
-import { assertEx as assertEx14, Base } from "@xylabs/sdk-js";
+import { assertEx as assertEx15, Base } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
 import { asXL1BlockNumber as asXL1BlockNumber3, defaultTransactionFees as defaultTransactionFees3, isAllowedBlockPayload as isAllowedBlockPayload4, minTransactionFees, XYO_ZERO_ADDRESS } from "@xyo-network/xl1-protocol";
 var TransactionBuilder = class extends Base {
@@ -1357,9 +1496,9 @@ var TransactionBuilder = class extends Base {
     super(options);
   }
   async build() {
-    const chain = assertEx14(this._chain, () => "Chain must be set before building the transaction");
-    const fees = assertEx14(this._fees, () => "Fees must be set before building the transaction");
-    const blockRange = assertEx14(this._blockRange, () => "Block range must be set before building the transaction");
+    const chain = assertEx15(this._chain, () => "Chain must be set before building the transaction");
+    const fees = assertEx15(this._fees, () => "Fees must be set before building the transaction");
+    const blockRange = assertEx15(this._blockRange, () => "Block range must be set before building the transaction");
     return await buildTransaction(chain, this._elevatedPayloads, this._payloads, this._signers, asXL1BlockNumber3(blockRange[0], true), asXL1BlockNumber3(blockRange[1], true), this._signers[0]?.address, fees);
   }
   chain(chain) {
@@ -1371,7 +1510,7 @@ var TransactionBuilder = class extends Base {
   }
   elevatedPayload(payload) {
     const allowedPayload = isAllowedBlockPayload4(payload) ? payload : void 0;
-    const allowPayloadExists = assertEx14(allowedPayload, () => "Payload must be an AllowedBlockPayload");
+    const allowPayloadExists = assertEx15(allowedPayload, () => "Payload must be an AllowedBlockPayload");
     this._elevatedPayloads.push(allowPayloadExists);
     return this;
   }
@@ -1467,25 +1606,13 @@ var bundle2 = /* @__PURE__ */ __name((root, transaction) => {
 }, "bundle");
 
 // src/model/Provider.ts
-import { assertEx as assertEx15, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx16, isString } from "@xylabs/sdk-js";
 var asProviderMoniker = /* @__PURE__ */ __name((value) => {
   const moniker = isString(value) ? value : void 0;
-  return assertEx15(moniker);
+  return assertEx16(moniker);
 }, "asProviderMoniker");
 var DefaultProviderMoniker = "Provider";
 
-// src/model/Qualified.ts
-import { HashZod } from "@xylabs/sdk-js";
-import { XL1BlockRangeZod } from "@xyo-network/xl1-protocol";
-import z from "zod";
-var QualifiedZod = /* @__PURE__ */ __name((zodType) => {
-  return z.tuple([
-    zodType,
-    XL1BlockRangeZod,
-    HashZod
-  ]);
-}, "QualifiedZod");
-
 // src/block/primitives/blockFromBlockNumber.ts
 async function blockFromBlockNumber(context, blockNumber) {
   const cacheKey = `${blockNumber}`;
@@ -2059,12 +2186,14 @@ var RewardRedemptionApiConfigZod = z10.object({
 import { globalRegistry as globalRegistry9 } from "zod";
 import * as z11 from "zod";
 var ServicesConfigZod = z11.object({
-  accountBalanceViewerEndpoint: z11.string().optional().register(globalRegistry9, {
+  accountBalanceViewerEndpoint: z11.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
+    default: "http://localhost:8080/rpc",
     description: "Endpoint of the API to use for instantiating an external AccountBalanceViewer",
     title: "services.accountBalanceViewerEndpoint",
     type: "string"
   }),
-  apiEndpoint: z11.string().optional().register(globalRegistry9, {
+  apiEndpoint: z11.string().default("http://localhost:8080/rpc").register(globalRegistry9, {
+    default: "http://localhost:8080/rpc",
     description: "Endpoint of the API to use for instantiating an external Viewers",
     title: "services.apiEndpoint",
     type: "string"
@@ -2240,10 +2369,10 @@ function isUsageMeta(v) {
 __name(isUsageMeta, "isUsageMeta");
 
 // src/CreatableProvider/AbstractCreatableProvider.ts
-import { AbstractCreatable, assertEx as assertEx17 } from "@xylabs/sdk-js";
+import { AbstractCreatable, assertEx as assertEx18 } from "@xylabs/sdk-js";
 
 // src/CreatableProvider/ProviderFactory.ts
-import { assertEx as assertEx16 } from "@xylabs/sdk-js";
+import { assertEx as assertEx17 } from "@xylabs/sdk-js";
 var ProviderFactory = class _ProviderFactory {
   static {
     __name(this, "ProviderFactory");
@@ -2260,7 +2389,7 @@ var ProviderFactory = class _ProviderFactory {
     this.defaultMoniker = creatableProvider2.defaultMoniker;
     this.monikers = creatableProvider2.monikers;
     this.scope = scope;
-    assertEx16(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
+    assertEx17(this.monikers.includes(this.defaultMoniker), () => "defaultMoniker must be in monikers");
     this.labels = Object.assign({}, creatableProvider2.labels ?? {}, labels ?? {});
   }
   get resolvedMoniker() {
@@ -2289,7 +2418,7 @@ var ProviderFactory = class _ProviderFactory {
         break;
       }
       case "context": {
-        const context = assertEx16(params?.context, () => "Context is required for context-scoped providers");
+        const context = assertEx17(params?.context, () => "Context is required for context-scoped providers");
         if (context.singletons === void 0) {
           context.singletons = {};
         }
@@ -2313,11 +2442,12 @@ var ProviderFactory = class _ProviderFactory {
         }
       }
     };
-    const result = await this.creatableProvider.create(mergedParams);
+    const resultPromise = scopeObject[this.resolvedMoniker] ?? this.creatableProvider.create(mergedParams);
+    scopeObject[this.resolvedMoniker] = resultPromise;
+    const result = await resultPromise;
     if (start) {
-      assertEx16(await result.start(), () => "Failed to start provider instance");
+      assertEx17(await result.start(), () => "Failed to start provider instance");
     }
-    scopeObject[this.resolvedMoniker] = result;
     return result;
   }
   async tryGetInstance(params, start = true) {
@@ -2336,13 +2466,13 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
   }
   _contextCache;
   get config() {
-    return assertEx17(this.context.config, () => "config is required");
+    return this.context.config;
   }
   get context() {
-    return assertEx17(this.params.context, () => "context is required");
+    return this.params.context;
   }
   get locator() {
-    return assertEx17(this.context.locator, () => "locator is required");
+    return this.context.locator;
   }
   static factory(params) {
     const factory = ProviderFactory.withParams(this, params);
@@ -2352,6 +2482,21 @@ var AbstractCreatableProvider = class extends AbstractCreatable {
     const instance = await this.create(inParams);
     return instance;
   }
+  static async paramsHandler(params = {}) {
+    const context = assertEx18(params.context, () => new Error("Context is required"));
+    const config = assertEx18(context.config, () => new Error("Context config is required"));
+    const locator = assertEx18(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
+    });
+  }
   static async tryGetInstance(inParams) {
     try {
       return await this.create(inParams);
@@ -2384,6 +2529,7 @@ var buildProviderFactory = /* @__PURE__ */ __name((provider, labels) => {
   const factory = {
     monikers: provider.monikers,
     // Copy static methods
+    // eslint-disable-next-line sonarjs/deprecation
     create: provider.create.bind(provider),
     // Merge module & supplied labels
     labels: {
@@ -2460,7 +2606,7 @@ __name(labeledCreatableProviderFactory, "labeledCreatableProviderFactory");
 
 // src/CreatableProvider/ProviderFactoryLocator.ts
 import { hasAllLabels } from "@xylabs/sdk-js";
-import { assertEx as assertEx18 } from "@xylabs/sdk-js";
+import { assertEx as assertEx19 } from "@xylabs/sdk-js";
 var ProviderFactoryLocator = class _ProviderFactoryLocator {
   static {
     __name(this, "ProviderFactoryLocator");
@@ -2506,7 +2652,8 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
       }
     };
     const factory = this.locate(moniker, labels);
-    return await factory.getInstance(resolvedParams);
+    const result = await factory.getInstance(resolvedParams);
+    return result;
   }
   /**
   * Locates a provider factory that matches the supplied moniker and labels
@@ -2515,7 +2662,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 assertEx18(this.tryLocate(moniker, labels), () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`);
+    return assertEx19(this.tryLocate(moniker, labels), () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ""} registered`);
   }
   merge(locator) {
     const registry = {
@@ -2536,7 +2683,7 @@ var ProviderFactoryLocator = class _ProviderFactoryLocator {
   * @param labels The labels for the module factory
   */
   register(factory, labels, primary = false) {
-    assertEx18(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
+    assertEx19(!this._frozen, () => "Cannot register a module factory after the locator has been frozen");
     registerCreatableProviderFactory(this._registry, factory, labels, primary);
     return this;
   }
@@ -2779,8 +2926,8 @@ var toPositiveBigInt = /* @__PURE__ */ __name((value) => {
 }, "toPositiveBigInt");
 
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
-import { asHash as asHash5, assertEx as assertEx22, exists as exists2, isDefined as isDefined16, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
-import { asRange, asXL1BlockNumber as asXL1BlockNumber8, asXL1BlockRange as asXL1BlockRange7, AttoXL1 as AttoXL12, StepSizes as StepSizes11, TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
+import { asHash as asHash5, assertEx as assertEx23, exists as exists3, isDefined as isDefined13, spanRootAsync as spanRootAsync4, ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { asRange, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange7, AttoXL1 as AttoXL12, StepSizes as StepSizes11, TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
 
 // src/summary/model/BalancesStepSummary.ts
 import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
@@ -2819,7 +2966,7 @@ var isTransfersStepSummaryWithStorageMeta = /* @__PURE__ */ __name((value) => {
 var asTransfersStepSummaryWithStorageMeta = AsObjectFactory7.create(isTransfersStepSummaryWithStorageMeta);
 
 // src/summary/primitives/balances/balancesStepSummaryFromRange.ts
-import { assertEx as assertEx19 } from "@xylabs/sdk-js";
+import { assertEx as assertEx20 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/payload-builder";
 import { isAnyPayload } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol";
@@ -2843,7 +2990,7 @@ async function balancesStepSummaryFromRange(context, range) {
     };
   } else {
     const step = StepSizes8.indexOf(frameSize);
-    assertEx19(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
+    assertEx20(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
     const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
     if (isAnyPayload(summaryResult)) {
       result = summaryResult;
@@ -2881,21 +3028,23 @@ async function balancesStepSummaryFromRange(context, range) {
 __name(balancesStepSummaryFromRange, "balancesStepSummaryFromRange");
 
 // src/summary/primitives/balances/balancesSummary.ts
-import { asAddress as asAddress3, isDefined as isDefined13, spanRootAsync } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockNumber as asXL1BlockNumber5, asXL1BlockRange as asXL1BlockRange4 } from "@xyo-network/xl1-protocol";
-async function balancesSummary(context) {
+import { asAddress as asAddress3, spanRootAsync } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, asXL1BlockRange as asXL1BlockRange4 } from "@xyo-network/xl1-protocol";
+async function balancesSummary(context, config) {
   return await spanRootAsync("balancesSummary", async () => {
-    const [headHash] = await context.head();
+    const [headHash] = isChainQualifiedHeadConfig(config) ? [
+      config.head
+    ] : await context.head();
     const headResult = await context.store.chainMap.get(headHash);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(headResult, () => `Head block not found for hash: ${headHash}`);
-    const rangeStart = asXL1BlockNumber5(isDefined13(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange4([
-      rangeStart,
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange4([
+      0,
       headBoundWitness.block
-    ], {
+    ], true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange4(range, {
       name: "balancesSummary"
     }));
-    const summaries = await Promise.all(ranges.map((range) => balancesStepSummaryFromRange(context, range)));
+    const summaries = await Promise.all(ranges.map((range2) => balancesStepSummaryFromRange(context, range2)));
     const balances = {};
     for (let summary of summaries) {
       for (const [address, balance] of Object.entries(summary.balances)) {
@@ -2905,18 +3054,17 @@ async function balancesSummary(context) {
     }
     return [
       balances,
-      [
-        rangeStart,
-        headBoundWitness.block
-      ],
-      headHash
+      {
+        range,
+        head: headHash
+      }
     ];
   });
 }
 __name(balancesSummary, "balancesSummary");
 
 // src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
-import { assertEx as assertEx20 } from "@xylabs/sdk-js";
+import { assertEx as assertEx21 } from "@xylabs/sdk-js";
 import { isBoundWitness } from "@xyo-network/boundwitness-model";
 import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/payload-builder";
 import { isAnyPayload as isAnyPayload2, isHashMeta } from "@xyo-network/payload-model";
@@ -2948,7 +3096,7 @@ async function schemasStepSummaryFromRange(context, range) {
     };
   } else {
     const step = StepSizes9.indexOf(frameSize);
-    assertEx20(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
+    assertEx21(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
     const summaryResult = await context.summaryMap.get(`${frameHeadHash}|${frameSize}`);
     if (isAnyPayload2(summaryResult)) {
       result = summaryResult;
@@ -2981,21 +3129,23 @@ async function schemasStepSummaryFromRange(context, range) {
 __name(schemasStepSummaryFromRange, "schemasStepSummaryFromRange");
 
 // src/summary/primitives/schemas/schemasSummary.ts
-import { isDefined as isDefined14, spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockNumber as asXL1BlockNumber6, asXL1BlockRange as asXL1BlockRange5 } from "@xyo-network/xl1-protocol";
-async function schemasSummary(context) {
+import { spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asXL1BlockRange as asXL1BlockRange5 } from "@xyo-network/xl1-protocol";
+async function schemasSummary(context, config) {
   return await spanRootAsync2("schemasSummary", async () => {
-    const [headHash] = await context.head();
+    const [headHash] = isChainQualifiedHeadConfig(config) ? [
+      config.head
+    ] : await context.head();
     const headResult = await context.store.chainMap.get(headHash);
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(headResult, () => `Head block not found for hash: ${headHash}`);
-    const rangeStart = asXL1BlockNumber6(isDefined14(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange5([
-      rangeStart,
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange5([
+      0,
       headBoundWitness.block
-    ], {
+    ], true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange5(range, {
       name: "schemasSummary"
     }));
-    const summaries = await Promise.all(ranges.map((range) => schemasStepSummaryFromRange(context, range)));
+    const summaries = await Promise.all(ranges.map((range2) => schemasStepSummaryFromRange(context, range2)));
     const results = {};
     for (let summary of summaries) {
       for (const [schema, count] of Object.entries(summary.schemas)) {
@@ -3004,38 +3154,39 @@ async function schemasSummary(context) {
     }
     return [
       results,
-      [
-        rangeStart,
-        headBoundWitness.block
-      ],
-      headHash
+      {
+        range,
+        head: headHash
+      }
     ];
   });
 }
 __name(schemasSummary, "schemasSummary");
 
 // src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
-import { assertEx as assertEx21 } from "@xylabs/sdk-js";
+import { assertEx as assertEx22 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/payload-builder";
 import { isAnyPayload as isAnyPayload3 } from "@xyo-network/payload-model";
 import { StepSizes as StepSizes10 } from "@xyo-network/xl1-protocol";
 
 // src/summary/primitives/transfers/transfersSummary.ts
-import { asAddress as asAddress4, isDefined as isDefined15, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockNumber as asXL1BlockNumber7, asXL1BlockRange as asXL1BlockRange6 } from "@xyo-network/xl1-protocol";
-async function transfersSummary(transferContext) {
+import { asAddress as asAddress4, spanRootAsync as spanRootAsync3 } from "@xylabs/sdk-js";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4, asXL1BlockRange as asXL1BlockRange6 } from "@xyo-network/xl1-protocol";
+async function transfersSummary(context, config) {
   return await spanRootAsync3("transferSummary", async () => {
-    const [headHash] = await transferContext.head();
-    const headResult = await transferContext.store.chainMap.get(headHash);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(headResult, () => `Head block not found for hash: ${transferContext.head}`);
-    const rangeStart = asXL1BlockNumber7(isDefined15(transferContext.windowSize) ? Math.max(headBoundWitness.block - transferContext.windowSize + 1, 0) : 0, true);
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange6([
-      rangeStart,
+    const [headHash] = isChainQualifiedHeadConfig(config) ? [
+      config.head
+    ] : await context.head();
+    const headResult = await context.store.chainMap.get(headHash);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(headResult, () => `Head block not found for hash: ${headHash}`);
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange6([
+      0,
       headBoundWitness.block
-    ], {
+    ], true);
+    const ranges = deepCalculateFramesFromRange(asXL1BlockRange6(range, {
       name: "transfersSummary"
     }));
-    const summaries = await Promise.all(ranges.map((range) => transfersStepSummaryFromRange(transferContext, range)));
+    const summaries = await Promise.all(ranges.map((range2) => transfersStepSummaryFromRange(context, range2)));
     const transfers = {};
     for (let summary of summaries) {
       for (const [from, toMap] of Object.entries(summary.transfers)) {
@@ -3049,11 +3200,10 @@ async function transfersSummary(transferContext) {
     }
     return [
       transfers,
-      [
-        rangeStart,
-        headBoundWitness.block
-      ],
-      headHash
+      {
+        range,
+        head: headHash
+      }
     ];
   });
 }
@@ -3087,7 +3237,7 @@ async function transfersStepSummaryFromRange(context, range) {
     };
   } else {
     const step = StepSizes10.indexOf(frameSize);
-    assertEx21(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
+    assertEx22(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
     const key = transfersSummaryKey(frameHeadHash, frameSize);
     const summaryResult = await context.summaryMap.get(key);
     if (isAnyPayload3(summaryResult)) {
@@ -3132,6 +3282,7 @@ async function transfersStepSummaryFromRange(context, range) {
 __name(transfersStepSummaryFromRange, "transfersStepSummaryFromRange");
 
 // src/viewers/AccountBalance.ts
+import { zodIsFactory as zodIsFactory2 } from "@xylabs/zod";
 import { WithHashMetaZod } from "@xyo-network/payload-model";
 import { TransferZod } from "@xyo-network/xl1-protocol";
 import { BlockBoundWitnessZod, TransactionBoundWitnessZod } from "@xyo-network/xl1-protocol";
@@ -3141,6 +3292,10 @@ var AccountBalanceHistoryItemZod = z21.tuple([
   WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
   WithHashMetaZod(TransferZod)
 ]);
+var AccountBalanceQualificationZod = ChainQualificationZod;
+var isAccountBalanceQualification = zodIsFactory2(AccountBalanceQualificationZod);
+var AccountBalanceConfigZod = ChainQualifiedConfigZod;
+var isAccountBalanceCOnfig = zodIsFactory2(AccountBalanceConfigZod);
 var AccountBalanceViewerMoniker = "AccountBalanceViewer";
 
 // src/viewers/Block.ts
@@ -3149,6 +3304,24 @@ var BlockViewerMoniker = "BlockViewer";
 // src/viewers/BlockReward.ts
 var BlockRewardViewerMoniker = "BlockRewardViewer";
 
+// src/viewers/BlockValidation.ts
+import { zodIsFactory as zodIsFactory3 } from "@xylabs/zod";
+import z22 from "zod";
+var BlockValidationQualificationZod = ChainQualificationZod;
+var isBlockValidationQualification = zodIsFactory3(BlockValidationQualificationZod);
+var BlockValidationConfigFieldsZod = z22.object({
+  value: z22.boolean().optional(),
+  state: z22.boolean().optional()
+});
+var BlockValidationConfigZod = z22.union([
+  BlockValidationConfigFieldsZod.extend(ChainQualifiedHeadConfigZod.shape),
+  BlockValidationConfigFieldsZod.extend(ChainQualifiedRangeConfigZod.shape),
+  BlockValidationConfigFieldsZod,
+  z22.object({})
+]);
+var isBlockValidationConfig = zodIsFactory3(BlockValidationConfigZod);
+var BlockValidationViewerMoniker = "BlockValidationViewer";
+
 // src/viewers/ChainContract.ts
 var ChainContractViewerMoniker = "ChainContractViewer";
 
@@ -3158,15 +3331,15 @@ var ChainStakeViewerMoniker = "ChainStakeViewer";
 // src/viewers/Mempool.ts
 import { HashZod as HashZod3 } from "@xylabs/sdk-js";
 import { XL1BlockRangeZod as XL1BlockRangeZod2 } from "@xyo-network/xl1-protocol";
-import z22 from "zod";
-var PendingTransactionsOptionsZod = z22.object({
+import z23 from "zod";
+var PendingTransactionsOptionsZod = z23.object({
   cursor: HashZod3.optional(),
-  limit: z22.number().int().positive().optional(),
+  limit: z23.number().int().positive().optional(),
   window: XL1BlockRangeZod2.optional()
 });
-var PendingBlocksOptionsZod = z22.object({
+var PendingBlocksOptionsZod = z23.object({
   cursor: HashZod3.optional(),
-  limit: z22.number().int().positive().optional(),
+  limit: z23.number().int().positive().optional(),
   window: XL1BlockRangeZod2.optional()
 });
 var MempoolViewerMoniker = "MempoolViewer";
@@ -3198,6 +3371,14 @@ var StepViewerMoniker = "StepViewer";
 // src/viewers/TimeSync.ts
 var TimeSyncViewerMoniker = "TimeSyncViewer";
 
+// src/viewers/TransactionValidation.ts
+import { zodIsFactory as zodIsFactory4 } from "@xylabs/zod";
+var TransactionValidationQualificationZod = ChainQualificationZod;
+var isTransactionValidationQualification = zodIsFactory4(TransactionValidationQualificationZod);
+var TransactionValidationConfigZod = ChainQualifiedConfigZod;
+var isTransactionValidationConfig = zodIsFactory4(TransactionValidationConfigZod);
+var TransactionValidationViewerMoniker = "TransactionValidationViewer";
+
 // src/viewers/TransferBalance.ts
 var TransferBalanceViewerMoniker = "TransferBalanceViewer";
 
@@ -3229,36 +3410,36 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     return this.params.transfersSummaryContext;
   }
   static async paramsHandler(params = {}) {
-    assertEx22(params.transfersSummaryContext, () => "transfersSummaryContext is required");
-    assertEx22(params.balanceSummaryContext, () => "balanceSummaryContext is required");
+    assertEx23(params.transfersSummaryContext, () => "transfersSummaryContext is required");
+    assertEx23(params.balanceSummaryContext, () => "balanceSummaryContext is required");
     return await super.paramsHandler({
       ...params
     });
   }
-  async accountBalance(address, headOrRange) {
+  async accountBalance(address, config) {
     const balances = await this.accountBalances([
       address
-    ], headOrRange);
+    ], config);
     return balances[address] ?? AttoXL12(0n);
   }
-  accountBalanceHistories(_addresses, _rangeOrHash) {
-    throw new Error("Method [accountBalanceHistories] not implemented.");
+  async accountBalanceHistories(addresses, config = {}) {
+    return (await this.qualifiedAccountBalanceHistories(addresses, config))[0];
   }
-  async accountBalanceHistory(address, headOrRange) {
-    const range = asRange(headOrRange);
+  async accountBalanceHistory(address, config) {
+    const range = isChainQualifiedRangeConfig(config) ? config.range : void 0;
     const startingRange = asXL1BlockRange7(range ?? [
       0,
       await this.blockViewer.currentBlockNumber()
     ], true);
     const blockNumbers = await this.distillTransferHistory(address, startingRange);
-    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists2);
+    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists3);
     const result = [];
     for (const block of blocks) {
-      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists2);
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
       const transfers = transferIndexes.map((index) => {
         const hash = block[0].payload_hashes[index];
-        return assertEx22(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
-      }).filter(exists2).filter((t) => t.from === address || isDefined16(t.transfers[address]));
+        return assertEx23(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists3).filter((t) => t.from === address || isDefined13(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -3276,19 +3457,19 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     }
     return result;
   }
-  async accountBalances(address, _headOrRange) {
-    const [result] = await this.qualifiedAccountBalances(address, _headOrRange);
+  async accountBalances(address, config) {
+    const [result] = await this.qualifiedAccountBalances(address, config ?? {});
     return result;
   }
   async createHandler() {
     await super.createHandler();
     this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
   }
-  async qualifiedAccountBalanceHistories(addresses, headOrRange) {
-    const head = asHash5(headOrRange) ?? await this.blockViewer.currentBlockHash();
-    const range = asXL1BlockRange7(headOrRange) ?? asXL1BlockRange7([
+  async qualifiedAccountBalanceHistories(addresses, config) {
+    const head = isChainQualifiedHeadConfig(config) ? config.head : await this.blockViewer.currentBlockHash();
+    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange7([
       0,
-      assertEx22(await this.blockViewer.blockByHash(head), () => `Error: Could not find block with hash ${head}`)[0].block
+      assertEx23(await this.blockViewer.blockByHash(head), () => `Error: Could not find block with hash ${head}`)[0].block
     ]);
     const qualifiedEntries = await Promise.all(addresses.map(async (address) => [
       address,
@@ -3300,21 +3481,25 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
         history
       ];
     });
-    const qualifiedRange = qualifiedEntries[0][1][1];
-    const qualifiedHeadHash = qualifiedEntries[0][1][2];
-    for (const [_, [__, range2, headHash]] of qualifiedEntries) {
-      assertEx22(range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1], () => "Inconsistent ranges in qualifiedAccountBalanceHistories");
-      assertEx22(headHash === qualifiedHeadHash, () => "Inconsistent head hashes in qualifiedAccountBalanceHistories");
+    const qualifiedRange = qualifiedEntries[0][1][1].range;
+    const qualifiedHeadHash = qualifiedEntries[0][1][1].head;
+    for (const [_, [__, { range: range2, head: head2 }]] of qualifiedEntries) {
+      assertEx23(range2[0] === qualifiedRange[0] && range2[1] === qualifiedRange[1], () => "Inconsistent ranges in qualifiedAccountBalanceHistories");
+      assertEx23(head2 === qualifiedHeadHash, () => "Inconsistent head hashes in qualifiedAccountBalanceHistories");
     }
     return [
       Object.fromEntries(entries),
-      qualifiedRange,
-      qualifiedHeadHash
+      {
+        range: qualifiedRange,
+        head: qualifiedHeadHash
+      }
     ];
   }
-  async qualifiedAccountBalances(address, _headOrRange) {
+  async qualifiedAccountBalances(address, config) {
     return await spanRootAsync4("qualifiedAccountsBalances", async () => {
-      const qualifiedSummary = await balancesSummary(this.balanceSummaryContext);
+      const qualifiedSummary = await balancesSummary({
+        ...this.balanceSummaryContext
+      }, config);
       const result = {};
       for (const addr of address) {
         const summaryBalance = qualifiedSummary[0][addr] ?? 0n;
@@ -3322,16 +3507,22 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
       }
       return [
         result,
-        qualifiedSummary[1],
-        qualifiedSummary[2]
+        qualifiedSummary[1]
       ];
     });
   }
+  async startHandler() {
+    await super.startHandler();
+    await Promise.all([
+      this.accountBalance(ZERO_ADDRESS),
+      this.accountBalanceHistory(ZERO_ADDRESS)
+    ]);
+  }
   async distillTransferHistory(address, range, max = 50) {
     if (range[1] - range[0] <= StepSizes11[0] || max <= 1) {
       return Array.from({
         length: range[1] - range[0] + 1
-      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber8(n, true));
+      }, (_, i) => range[1] - i).slice(0, max).map((n) => asXL1BlockNumber5(n, true));
     }
     const frames = deepCalculateFramesFromRange(asXL1BlockRange7(range, true));
     const transferSummaryPairs = await Promise.all(frames.map(async (frame) => {
@@ -3371,20 +3562,20 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
   async qualifiedAccountBalanceHistory(address, headOrRange) {
     const range = asRange(headOrRange);
     const headHash = asHash5(headOrRange);
-    const [head] = assertEx22(isDefined16(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
+    const [head] = assertEx23(isDefined13(headHash) ? await this.blockViewer.blockByHash(headHash) : await this.blockViewer.currentBlock(), () => "Could not resolve head block");
     const startingRange = asXL1BlockRange7(range ?? [
       0,
       head.block
     ], true);
     const blockNumbers = await this.distillTransferHistory(address, startingRange);
-    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists2);
+    const blocks = (await Promise.all(blockNumbers.map(async (bn) => await this.blockViewer.blockByNumber(bn)))).filter(exists3);
     const result = [];
     for (const block of blocks) {
-      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists2);
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema2 ? index : void 0).filter(exists3);
       const transfers = transferIndexes.map((index) => {
         const hash = block[0].payload_hashes[index];
-        return assertEx22(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
-      }).filter(exists2).filter((t) => t.from === address || isDefined16(t.transfers[address]));
+        return assertEx23(block[1].find((p) => p._hash === hash), () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`);
+      }).filter(exists3).filter((t) => t.from === address || isDefined13(t.transfers[address]));
       if (transfers.length === 0) {
         continue;
       }
@@ -3402,8 +3593,10 @@ var SimpleAccountBalanceViewer = class _SimpleAccountBalanceViewer extends Abstr
     }
     return [
       result,
-      startingRange,
-      head._hash
+      {
+        range: startingRange,
+        head: head._hash
+      }
     ];
   }
 };
@@ -3412,8 +3605,8 @@ SimpleAccountBalanceViewer = _ts_decorate([
 ], SimpleAccountBalanceViewer);
 
 // src/simple/block/SimpleBlockViewer.ts
-import { assertEx as assertEx23, exists as exists3, isDefined as isDefined17, isUndefined as isUndefined5, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
-import { asSignedHydratedBlockWithHashMeta, asXL1BlockNumber as asXL1BlockNumber9 } from "@xyo-network/xl1-protocol";
+import { assertEx as assertEx24, exists as exists4, isDefined as isDefined14, isUndefined as isUndefined5, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
+import { asSignedHydratedBlockWithHashMeta, asXL1BlockNumber as asXL1BlockNumber6 } from "@xyo-network/xl1-protocol";
 
 // src/utils/HydratedCache.ts
 import { LRUCache as LRUCache2 } from "lru-cache";
@@ -3446,12 +3639,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import * as z23 from "zod";
+import * as z24 from "zod";
 var isZodError = /* @__PURE__ */ __name((error) => {
-  return error instanceof z23.ZodError;
+  return error instanceof z24.ZodError;
 }, "isZodError");
 var prettifyZodError = /* @__PURE__ */ __name((error) => {
-  return z23.prettifyError(error);
+  return z24.prettifyError(error);
 }, "prettifyZodError");
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -3497,7 +3690,7 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
     return this._store;
   }
   static async paramsHandler(params) {
-    assertEx23(params.finalizedArchivist, () => "finalizedArchivist is required");
+    assertEx24(params.finalizedArchivist, () => "finalizedArchivist is required");
     return {
       ...await super.paramsHandler(params)
     };
@@ -3529,8 +3722,8 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
   }
   async blocksByHash(hash, limit = 50) {
     return await spanRootAsync5("blocksByHash", async () => {
-      assertEx23(limit > 0, () => "limit must be greater than 0");
-      assertEx23(limit <= 100, () => "limit must be less than 100");
+      assertEx24(limit > 0, () => "limit must be greater than 0");
+      assertEx24(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByHash(hash);
       while (current && blocks.length < limit) {
@@ -3544,14 +3737,14 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
   }
   async blocksByNumber(blockNumber, limit = 50) {
     return await spanRootAsync5("blocksByHash", async () => {
-      assertEx23(limit > 0, () => "limit must be greater than 0");
-      assertEx23(limit <= 100, () => "limit must be less than 100");
+      assertEx24(limit > 0, () => "limit must be greater than 0");
+      assertEx24(limit <= 100, () => "limit must be less than 100");
       const blocks = [];
       let current = await this.blockByNumber(blockNumber);
       while (current && blocks.length < limit) {
         blocks.push(current);
         if (current[0].block === 0) break;
-        const previousNumber = asXL1BlockNumber9(current[0].block - 1, true);
+        const previousNumber = asXL1BlockNumber6(current[0].block - 1, true);
         current = await this.blockByNumber(previousNumber);
       }
       return blocks.map((b) => asSignedHydratedBlockWithHashMeta(b, true));
@@ -3559,7 +3752,7 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
   }
   async chainId(blockNumber = "latest") {
     return await spanRootAsync5("chainId", async () => {
-      const block = assertEx23(blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber), () => `Could not find block for block number ${blockNumber}`);
+      const block = assertEx24(blockNumber === "latest" ? await this.currentBlock() : await this.blockByNumber(blockNumber), () => `Could not find block for block number ${blockNumber}`);
       return block[0].chain;
     });
   }
@@ -3571,25 +3764,25 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
   }
   async currentBlock() {
     return await spanRootAsync5("currentBlock", async () => {
-      const currentHead = assertEx23(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
+      const currentHead = assertEx24(await this.getCurrentHead(), () => "Could not find most recent block [currentBlock]");
       const cache = this.hydratedBlockCache;
       const block = await cache.get(currentHead._hash);
       if (!block) {
         console.log(`Could not find current block with hash ${currentHead._hash}`);
       }
-      return assertEx23(block, () => "Could not find current block");
+      return assertEx24(block, () => "Could not find current block");
     }, this.tracer);
   }
   async currentBlockHash() {
     return await spanRootAsync5("currentBlockHash", async () => {
-      const currentHead = assertEx23(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockHash]");
+      const currentHead = assertEx24(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockHash]");
       return currentHead._hash;
     }, this.tracer);
   }
   async currentBlockNumber() {
     return await spanRootAsync5("currentBlockNumber", async () => {
-      const currentHead = assertEx23(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockNumber]");
-      return asXL1BlockNumber9(currentHead.block, {
+      const currentHead = assertEx24(await this.getCurrentHead(), () => "Could not find most recent block [currentBlockNumber]");
+      return asXL1BlockNumber6(currentHead.block, {
         name: "currentBlockNumber"
       });
     }, this.tracer);
@@ -3602,7 +3795,7 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
       const [result] = await this.finalizedArchivist.get([
         hash
       ]);
-      if (isDefined17(result)) {
+      if (isDefined14(result)) {
         await this.payloadCache.set(hash, result);
       }
       return result ?? null;
@@ -3618,7 +3811,7 @@ var SimpleBlockViewer = class _SimpleBlockViewer extends AbstractCreatableProvid
     const remainingPayloads = remainingHashes.length > 0 ? await this.finalizedArchivist.get(remainingHashes) : [];
     return [
       ...cachedPayloads,
-      ...remainingPayloads.filter(exists3)
+      ...remainingPayloads.filter(exists4)
     ];
   }
   async getCurrentHead() {
@@ -3656,9 +3849,9 @@ SimpleBlockRewardViewer = _ts_decorate3([
   creatableProvider()
 ], SimpleBlockRewardViewer);
 
-// src/simple/chainStake/SimpleStakeViewer.ts
-import { asAddress as asAddress5, toAddress as toAddress9 } from "@xylabs/sdk-js";
-import { assertEx as assertEx24 } from "@xylabs/sdk-js";
+// src/simple/blockValidation/SimpleBlockValidationViewer.ts
+import { exists as exists5 } from "@xylabs/sdk-js";
+import { asXL1BlockRange as asXL1BlockRange8 } from "@xyo-network/xl1-protocol";
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -3666,6 +3859,110 @@ function _ts_decorate4(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate4, "_ts_decorate");
+var SimpleBlockValidationViewer = class _SimpleBlockValidationViewer extends AbstractCreatableProvider {
+  static {
+    __name(this, "SimpleBlockValidationViewer");
+  }
+  static defaultMoniker = BlockValidationViewerMoniker;
+  static monikers = [
+    BlockValidationViewerMoniker
+  ];
+  moniker = _SimpleBlockValidationViewer.defaultMoniker;
+  _accountBalanceViewer;
+  _blockViewer;
+  _uncleWindowedChainCache = null;
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  get maxUncleWindowSize() {
+    return this.params.maxUncleWindowSize;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      maxUncleWindowSize: params.maxUncleWindowSize ?? 100
+    };
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker);
+  }
+  async qualifiedValidateBlock(block, config) {
+    return await this.qualifiedValidateBlocks([
+      block
+    ], config);
+  }
+  async qualifiedValidateBlocks(blocks, config) {
+    const { value, state } = config ?? {
+      shape: true,
+      links: true,
+      state: true
+    };
+    const [headBlock] = await this.blockViewer.currentBlock();
+    const chainId = headBlock.chain;
+    const validateValue = value ? this.doValidateValue.bind(this) : void 0;
+    const validateState = state ? this.doValidateState.bind(this) : void 0;
+    return [
+      (await Promise.all([
+        validateValue?.(blocks, chainId),
+        validateState?.(blocks, chainId)
+      ].filter(exists5))).flat(),
+      {
+        head: headBlock._hash,
+        range: asXL1BlockRange8([
+          0,
+          headBlock.block
+        ], true)
+      }
+    ];
+  }
+  async validateBlock(block, config) {
+    return await this.validateBlocks([
+      block
+    ], config);
+  }
+  async validateBlocks(blocks, config) {
+    return (await this.qualifiedValidateBlocks(blocks, config))[0];
+  }
+  async doValidateState(blocks, chainId) {
+    const windowedUncleChain = await this.updateWindowedChainCache();
+    const uncles = findUncles(this.context, windowedUncleChain, blocks);
+    if (uncles.length !== 1) {
+      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}]`);
+    }
+    return (await Promise.all(uncles[0].map(async (block) => {
+      return await this.params.state(block, chainId, {
+        accountBalance: this._accountBalanceViewer
+      });
+    }))).flat();
+  }
+  async doValidateValue(blocks, chainId) {
+    return (await Promise.all(blocks.map(async (block) => {
+      return await this.params.value(block, chainId);
+    }))).flat();
+  }
+  async updateWindowedChainCache() {
+    this._uncleWindowedChainCache = await getWindowedChain(this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? []);
+    return [
+      ...this._uncleWindowedChainCache
+    ];
+  }
+};
+SimpleBlockValidationViewer = _ts_decorate4([
+  creatableProvider()
+], SimpleBlockValidationViewer);
+
+// src/simple/chainStake/SimpleStakeViewer.ts
+import { asAddress as asAddress5, toAddress as toAddress9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx25 } from "@xylabs/sdk-js";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
 var SimpleStakeViewer = class _SimpleStakeViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleStakeViewer");
@@ -3686,7 +3983,7 @@ var SimpleStakeViewer = class _SimpleStakeViewer extends AbstractCreatableProvid
     return toAddress9(toAddress9(1n));
   }
   get stakeEvents() {
-    return assertEx24(this._chainStakeEventsViewer, () => "Stake events viewer not set");
+    return assertEx25(this._chainStakeEventsViewer, () => "Stake events viewer not set");
   }
   get stakingTokenAddress() {
     return toAddress9("0x000000000000000000000000000011");
@@ -3723,7 +4020,7 @@ var SimpleStakeViewer = class _SimpleStakeViewer extends AbstractCreatableProvid
   }
   async createHandler() {
     await super.createHandler();
-    this._chainStakeEventsViewer = assertEx24(await this.locateAndCreate(StakeEventsViewerMoniker), () => "Failed to create StakeEventsViewer");
+    this._chainStakeEventsViewer = assertEx25(await this.locateAndCreate(StakeEventsViewerMoniker), () => "Failed to create StakeEventsViewer");
   }
   pending() {
     let pending = 0n;
@@ -3744,7 +4041,7 @@ var SimpleStakeViewer = class _SimpleStakeViewer extends AbstractCreatableProvid
     return pending;
   }
   stakeById(id) {
-    return assertEx24(this.positions[id], () => new Error(`Stake with id ${id} not found`));
+    return assertEx25(this.positions[id], () => new Error(`Stake with id ${id} not found`));
   }
   stakeByStaker(staker, slot) {
     return this.positions.filter((s) => asAddress5(s.staker) === asAddress5(staker))[slot];
@@ -3782,7 +4079,7 @@ var SimpleStakeViewer = class _SimpleStakeViewer extends AbstractCreatableProvid
     return withdrawn;
   }
 };
-SimpleStakeViewer = _ts_decorate4([
+SimpleStakeViewer = _ts_decorate5([
   creatableProvider()
 ], SimpleStakeViewer);
 
@@ -3847,13 +4144,13 @@ var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
 };
 
 // src/simple/datalake/SimpleDataLakeRunner.ts
-function _ts_decorate5(decorators, target, key, desc) {
+function _ts_decorate6(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate5, "_ts_decorate");
+__name(_ts_decorate6, "_ts_decorate");
 var SimpleDataLakeRunner = class _SimpleDataLakeRunner extends AbstractSimpleDataLake {
   static {
     __name(this, "SimpleDataLakeRunner");
@@ -3879,18 +4176,18 @@ var SimpleDataLakeRunner = class _SimpleDataLakeRunner extends AbstractSimpleDat
     return await this.map.setMany(allowed);
   }
 };
-SimpleDataLakeRunner = _ts_decorate5([
+SimpleDataLakeRunner = _ts_decorate6([
   creatableProvider()
 ], SimpleDataLakeRunner);
 
 // src/simple/datalake/SimpleDataLakeViewer.ts
-function _ts_decorate6(decorators, target, key, desc) {
+function _ts_decorate7(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate6, "_ts_decorate");
+__name(_ts_decorate7, "_ts_decorate");
 var SimpleDataLakeViewer = class _SimpleDataLakeViewer extends AbstractSimpleDataLake {
   static {
     __name(this, "SimpleDataLakeViewer");
@@ -3901,7 +4198,7 @@ var SimpleDataLakeViewer = class _SimpleDataLakeViewer extends AbstractSimpleDat
   ];
   moniker = _SimpleDataLakeViewer.defaultMoniker;
 };
-SimpleDataLakeViewer = _ts_decorate6([
+SimpleDataLakeViewer = _ts_decorate7([
   creatableProvider()
 ], SimpleDataLakeViewer);
 
@@ -3931,9 +4228,9 @@ var SimpleXyoGateway = class {
 };
 
 // src/simple/gateway/SimpleXyoGatewayRunner.ts
-import { assertEx as assertEx25, BigIntToJsonZod, isDefined as isDefined18 } from "@xylabs/sdk-js";
+import { assertEx as assertEx26, BigIntToJsonZod, isDefined as isDefined15 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/payload-builder";
-import { asXL1BlockNumber as asXL1BlockNumber10, TransferSchema as TransferSchema3 } from "@xyo-network/xl1-protocol";
+import { asXL1BlockNumber as asXL1BlockNumber7, TransferSchema as TransferSchema3 } from "@xyo-network/xl1-protocol";
 var SimpleXyoGatewayRunner = class {
   static {
     __name(this, "SimpleXyoGatewayRunner");
@@ -3962,18 +4259,18 @@ var SimpleXyoGatewayRunner = class {
     return this._dataLakes.length - 1;
   }
   async addPayloadsToChain(onChain, offChain, options) {
-    const viewer = assertEx25(this.connectionInstance.viewer, () => "No viewer available on connection");
+    const viewer = assertEx26(this.connectionInstance.viewer, () => "No viewer available on connection");
     const { nbf, exp, chain, fees } = options ?? {};
-    const resolvedChainId = isDefined18(chain) ? chain : await viewer.chainId();
-    const resolvedNbf = asXL1BlockNumber10(isDefined18(nbf) ? nbf : await viewer.currentBlockNumber(), true);
-    const resolvedExp = asXL1BlockNumber10(isDefined18(exp) ? exp : resolvedNbf + 10, true);
+    const resolvedChainId = isDefined15(chain) ? chain : await viewer.chainId();
+    const resolvedNbf = asXL1BlockNumber7(isDefined15(nbf) ? nbf : await viewer.currentBlockNumber(), true);
+    const resolvedExp = asXL1BlockNumber7(isDefined15(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await (await this.signer()).address(), fees);
     return await this.addTransactionToChain(tx);
   }
   async addTransactionToChain(tx) {
     const connection = this.connectionInstance;
     const signer = this.signerInstance;
-    const runner = assertEx25(connection.runner, () => "No runner available on connection");
+    const runner = assertEx26(connection.runner, () => "No runner available on connection");
     const signedTx = await signer.signTransaction(tx);
     await this.addPayloadsToDataLakes(signedTx[1]);
     return [
@@ -3985,7 +4282,7 @@ var SimpleXyoGatewayRunner = class {
     ];
   }
   async confirmSubmittedTransaction(txHash, options) {
-    return await confirmSubmittedTransaction(assertEx25(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
+    return await confirmSubmittedTransaction(assertEx26(this.connectionInstance.viewer, () => "Connection viewer is undefined"), txHash, options);
   }
   /** @deprecated use connectionInstance instead */
   connection() {
@@ -4032,13 +4329,13 @@ var SimpleXyoGatewayRunner = class {
 
 // src/simple/mempool/SimpleMempoolRunner.ts
 import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/payload-builder";
-function _ts_decorate7(decorators, target, key, desc) {
+function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate7, "_ts_decorate");
+__name(_ts_decorate8, "_ts_decorate");
 var SimpleMempoolRunner = class _SimpleMempoolRunner extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleMempoolRunner");
@@ -4075,20 +4372,20 @@ var SimpleMempoolRunner = class _SimpleMempoolRunner extends AbstractCreatablePr
     return inserted.map((p) => p._hash);
   }
 };
-SimpleMempoolRunner = _ts_decorate7([
+SimpleMempoolRunner = _ts_decorate8([
   creatableProvider()
 ], SimpleMempoolRunner);
 
 // src/simple/mempool/SimpleMempoolViewer.ts
-import { creatable, exists as exists4, isDefined as isDefined19, isHash } from "@xylabs/sdk-js";
+import { creatable, exists as exists6, isDefined as isDefined16, isHash } from "@xylabs/sdk-js";
 import { isHashMeta as isHashMeta2, isPayloadBundle } from "@xyo-network/payload-model";
-function _ts_decorate8(decorators, target, key, desc) {
+function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate8, "_ts_decorate");
+__name(_ts_decorate9, "_ts_decorate");
 var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleMempoolViewer");
@@ -4110,7 +4407,7 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       const [p] = await this.pendingBlocksArchivist.get([
         providedCursor
       ]);
-      if (isDefined19(p)) {
+      if (isDefined16(p)) {
         cursor = p._sequence;
       }
     }
@@ -4120,7 +4417,7 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       cursor
     });
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta2);
-    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists4);
+    return (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedBlock(bundle3)))).filter(exists6);
   }
   async pendingTransactions({ cursor: providedCursor } = {}) {
     let cursor = void 0;
@@ -4128,7 +4425,7 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
       const [p] = await this.pendingTransactionsArchivist.get([
         providedCursor
       ]);
-      if (isDefined19(p)) {
+      if (isDefined16(p)) {
         cursor = p._sequence;
       }
     }
@@ -4141,12 +4438,12 @@ var SimpleMempoolViewer = class _SimpleMempoolViewer extends AbstractCreatablePr
     this.logger?.info(`Fetched pending transactions: ${bundles.length} bundles`);
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta2);
     this.logger?.info(`Filtered pending transactions: ${JSON.stringify(bundles, null, 2)} filteredBundles`);
-    const result = (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedTransaction(bundle3)))).filter(exists4);
+    const result = (await Promise.all(filteredBundles.map(async (bundle3) => await bundledPayloadToHydratedTransaction(bundle3)))).filter(exists6);
     this.logger?.info(`Converted pending transactions: ${JSON.stringify(result, null, 2)} results`);
     return result;
   }
 };
-SimpleMempoolViewer = _ts_decorate8([
+SimpleMempoolViewer = _ts_decorate9([
   creatable()
 ], SimpleMempoolViewer);
 
@@ -4223,7 +4520,7 @@ var SimpleXyoNetwork = class {
 };
 
 // src/simple/permissions/SimpleXyoPermissions.ts
-import { assertEx as assertEx26 } from "@xylabs/sdk-js";
+import { assertEx as assertEx27 } from "@xylabs/sdk-js";
 var SimpleXyoPermissions = class {
   static {
     __name(this, "SimpleXyoPermissions");
@@ -4235,7 +4532,7 @@ var SimpleXyoPermissions = class {
     this.invoker = store.invoker;
   }
   get store() {
-    return assertEx26(this._store, () => "Store must be defined to get permissions");
+    return assertEx27(this._store, () => "Store must be defined to get permissions");
   }
   async getPermissions() {
     return await this.store.getPermissions();
@@ -4293,7 +4590,7 @@ var SimpleXyoPermissions = class {
 };
 
 // src/simple/permissions/store/MemoryPermissions.ts
-import { assertEx as assertEx27 } from "@xylabs/sdk-js";
+import { assertEx as assertEx28 } from "@xylabs/sdk-js";
 var MemoryPermissionsStore = class {
   static {
     __name(this, "MemoryPermissionsStore");
@@ -4304,7 +4601,7 @@ var MemoryPermissionsStore = class {
     this._invoker = invoker;
   }
   get invoker() {
-    return assertEx27(this._invoker, () => "Invoker must be defined to get permissions");
+    return assertEx28(this._invoker, () => "Invoker must be defined to get permissions");
   }
   async getPermissions() {
     await Promise.resolve();
@@ -4317,7 +4614,7 @@ var MemoryPermissionsStore = class {
 };
 
 // src/simple/runner/SimpleXyoRunner.ts
-import { assertEx as assertEx28 } from "@xylabs/sdk-js";
+import { assertEx as assertEx29 } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder19 } from "@xyo-network/payload-builder";
 var SimpleXyoRunner = class _SimpleXyoRunner extends AbstractCreatableProvider {
   static {
@@ -4335,7 +4632,7 @@ var SimpleXyoRunner = class _SimpleXyoRunner extends AbstractCreatableProvider {
   static async paramsHandler(params) {
     return {
       ...await super.paramsHandler(params),
-      pendingTransactionsArchivist: assertEx28(params?.pendingTransactionsArchivist, () => "A pendingTransactionsArchivist is required to create a SimpleXyoRunner")
+      pendingTransactionsArchivist: assertEx29(params?.pendingTransactionsArchivist, () => "A pendingTransactionsArchivist is required to create a SimpleXyoRunner")
     };
   }
   async broadcastTransaction(transaction) {
@@ -4386,14 +4683,14 @@ var SimpleXyoSigner = class {
 };
 
 // src/simple/stakeEvents/SimpleStakeEventsViewer.ts
-import { isDefined as isDefined20 } from "@xylabs/sdk-js";
-function _ts_decorate9(decorators, target, key, desc) {
+import { isDefined as isDefined17 } from "@xylabs/sdk-js";
+function _ts_decorate10(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate9, "_ts_decorate");
+__name(_ts_decorate10, "_ts_decorate");
 var SimpleStakeEventsViewer = class _SimpleStakeEventsViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleStakeEventsViewer");
@@ -4412,7 +4709,7 @@ var SimpleStakeEventsViewer = class _SimpleStakeEventsViewer extends AbstractCre
   stakeEvents(range, { name } = {}) {
     const positions = this.positionsFromRange(range);
     const events = this.eventsFromPositions(positions);
-    if (isDefined20(name)) {
+    if (isDefined17(name)) {
       return events.filter((event) => event.name === name);
     }
     return events;
@@ -4471,13 +4768,13 @@ var SimpleStakeEventsViewer = class _SimpleStakeEventsViewer extends AbstractCre
     return filteredPositions;
   }
 };
-SimpleStakeEventsViewer = _ts_decorate9([
+SimpleStakeEventsViewer = _ts_decorate10([
   creatableProvider()
 ], SimpleStakeEventsViewer);
 
 // src/simple/timesync/SimpleTimeSyncViewer.ts
-import { asHash as asHash6, assertEx as assertEx29, isDefined as isDefined21 } from "@xylabs/sdk-js";
-import { asTimePayload as asTimePayload2, asXL1BlockNumber as asXL1BlockNumber11, TimeSchema } from "@xyo-network/xl1-protocol";
+import { asHash as asHash6, assertEx as assertEx30, isDefined as isDefined18 } from "@xylabs/sdk-js";
+import { asTimePayload as asTimePayload2, asXL1BlockNumber as asXL1BlockNumber8, TimeSchema } from "@xyo-network/xl1-protocol";
 var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatableProvider {
   static {
     __name(this, "SimpleTimeSyncViewer");
@@ -4497,10 +4794,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
   async convertTime(fromDomain, toDomain, from) {
     switch (fromDomain) {
       case "xl1": {
-        const [block, payloads] = assertEx29(await this.blockViewer.blockByNumber(asXL1BlockNumber11(from, true)), () => "Block not found");
+        const [block, payloads] = assertEx30(await this.blockViewer.blockByNumber(asXL1BlockNumber8(from, true)), () => "Block not found");
         const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema);
         const hash = timeSchemaIndex === -1 ? void 0 : block.payload_hashes[timeSchemaIndex];
-        const timePayload = asTimePayload2(isDefined21(hash) ? payloads.find((p) => p._hash === hash) : void 0);
+        const timePayload = asTimePayload2(isDefined18(hash) ? payloads.find((p) => p._hash === hash) : void 0);
         if (timePayload === void 0) return 0;
         switch (toDomain) {
           case "xl1": {
@@ -4567,10 +4864,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
         ];
       }
       case "ethereum": {
-        const provider = assertEx29(this.ethProvider, () => "Ethereum provider not configured");
+        const provider = assertEx30(this.ethProvider, () => "Ethereum provider not configured");
         const blockNumber = await provider.getBlockNumber() ?? 0;
         const block = await provider.getBlock(blockNumber);
-        const blockHash = asHash6(assertEx29(block?.hash, () => "Block hash not found"), true);
+        const blockHash = asHash6(assertEx30(block?.hash, () => "Block hash not found"), true);
         return [
           blockNumber,
           blockHash
@@ -4588,10 +4885,10 @@ var SimpleTimeSyncViewer = class _SimpleTimeSyncViewer extends AbstractCreatable
       // this is for the previous block
       xl1,
       // this is for the previous block
-      xl1Hash: assertEx29(xl1Hash, () => "No xl1 hash available from time sync service"),
+      xl1Hash: assertEx30(xl1Hash, () => "No xl1 hash available from time sync service"),
       epoch: Date.now()
     };
-    if (isDefined21(this.ethProvider)) {
+    if (isDefined18(this.ethProvider)) {
       const [ethereum, ethHashOrNull] = await this.currentTimeAndHash("ethereum");
       const ethereumHash = asHash6(ethHashOrNull, () => "No ethereum hash available from time sync service");
       timePayload.ethereum = ethereum;
@@ -4692,7 +4989,7 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 };
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx30 } from "@xylabs/sdk-js";
+import { assertEx as assertEx31 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
@@ -4700,7 +4997,7 @@ async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const timePayload = asTimePayload3(hydratedBlock[1].find((p) => p.schema === TimeSchema2), {
     required: true
   });
-  return assertEx30(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx31(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 __name(xl1BlockNumberToEthBlockNumber, "xl1BlockNumberToEthBlockNumber");
 
@@ -4735,14 +5032,20 @@ export {
   ACCOUNT_TYPE,
   ADDRESS_INDEX,
   AbstractCreatableProvider,
+  AccountBalanceConfigZod,
   AccountBalanceHistoryItemZod,
+  AccountBalanceQualificationZod,
   AccountBalanceViewerMoniker,
   AddressPairSchema,
   BalancesStepSummarySchema,
   BasisPointsZod,
   BlockRewardViewerMoniker,
   BlockRunnerMoniker,
+  BlockValidationConfigFieldsZod,
+  BlockValidationConfigZod,
   BlockValidationError,
+  BlockValidationQualificationZod,
+  BlockValidationViewerMoniker,
   BlockViewerMoniker,
   BridgeConfigZod,
   BridgeSettingsZod,
@@ -4750,6 +5053,11 @@ export {
   COIN_TYPES,
   ChainContractViewerMoniker,
   ChainIndexingServiceStateSchema,
+  ChainQualificationZod,
+  ChainQualifiedConfigZod,
+  ChainQualifiedHeadConfigZod,
+  ChainQualifiedRangeConfigZod,
+  ChainQualifiedZod,
   ChainStakeViewerMoniker,
   ConfigZod,
   DEFAULT_WALLET_PATH,
@@ -4760,6 +5068,7 @@ export {
   EIP712DataPayloadSchema,
   EIP712SignaturePayloadFieldsZod,
   EIP712SignaturePayloadSchema,
+  ExtendChainQualifiedConfigZod,
   GlobalMetaSchema,
   HydratedBlockStateValidationError,
   HydratedBlockValidationError,
@@ -4783,12 +5092,12 @@ export {
   PendingTransactionsOptionsZod,
   ProviderFactory,
   ProviderFactoryLocator,
-  QualifiedZod,
   RewardMultipliers,
   RuntimeStatusMonitor,
   SchemasStepSummarySchema,
   SimpleAccountBalanceViewer,
   SimpleBlockRewardViewer,
+  SimpleBlockValidationViewer,
   SimpleBlockViewer,
   SimpleDataLakeRunner,
   SimpleDataLakeViewer,
@@ -4815,6 +5124,9 @@ export {
   TODO,
   TimeSyncViewerMoniker,
   TransactionBuilder,
+  TransactionValidationConfigZod,
+  TransactionValidationQualificationZod,
+  TransactionValidationViewerMoniker,
   TransferBalanceViewerMoniker,
   TransfersStepSummarySchema,
   TypedDataDomainZod,
@@ -4878,7 +5190,9 @@ export {
   externalBlockRangeFromXL1BlockRange,
   extractElevatedHashes,
   extractElevatedHashesFromScript,
+  findBestUncle,
   findMostRecentBlock,
+  findUncles,
   flattenHydratedBlock,
   flattenHydratedBlocks,
   flattenHydratedTransaction,
@@ -4886,6 +5200,7 @@ export {
   generateXyoBaseWalletFromPhrase,
   getDefaultConfig,
   getUrl,
+  getWindowedChain,
   hasLabels,
   hasMongoConfig,
   hashFromBlockNumber,
@@ -4895,12 +5210,20 @@ export {
   hydratedBlockByNumber,
   hydratedBlockToPayloadBundle,
   hydratedTransactionToPayloadBundle,
+  isAccountBalanceCOnfig,
+  isAccountBalanceQualification,
   isAddressPairPayload,
   isBalancesStepSummary,
   isBalancesStepSummaryWithStorageMeta,
+  isBlockValidationConfig,
   isBlockValidationError,
+  isBlockValidationQualification,
   isChainIndexingServiceState,
   isChainIndexingServiceStateWithStorageMeta,
+  isChainQualification,
+  isChainQualifiedConfig,
+  isChainQualifiedHeadConfig,
+  isChainQualifiedRangeConfig,
   isEIP712DataPayload,
   isEIP712SignaturePayload,
   isHydratedBlockStateValidationError,
@@ -4912,6 +5235,8 @@ export {
   isReadWriteArchivist,
   isSchemasStepSummary,
   isSchemasStepSummaryWithStorageMeta,
+  isTransactionValidationConfig,
+  isTransactionValidationQualification,
   isTransfersStepSummary,
   isTransfersStepSummaryWithStorageMeta,
   isUsageMeta,
@@ -4935,6 +5260,7 @@ export {
   rewardFromBlockNumber,
   schemasStepSummaryFromRange,
   schemasSummary,
+  scoreUncle,
   signEIP712Message,
   signTransaction,
   stepBlockRange,