@xyo-network/xl1-protocol-sdk 1.17.7 → 1.18.0

package/src/provider/XyoConnection.ts

@@ -1,9 +1,13 @@
+import type { Provider } from '../model/index.ts'
 import type { DataLakeRunner, DataLakeViewer } from './DataLake.ts'
 import type { NetworkStakeViewer, XyoViewer } from './viewer/index.ts'
 import type { XyoNetwork } from './XyoNetwork.ts'
 import type { XyoRunner } from './XyoRunner.ts'
 
-export interface XyoConnection {
+export const XyoConnectionMoniker = 'XyoConnection' as const
+export type XyoConnectionMoniker = typeof XyoConnectionMoniker
+
+export interface XyoConnection extends Provider<XyoConnectionMoniker> {
   network?: XyoNetwork
   networkStake?: NetworkStakeViewer
   runner?: XyoRunner

package/src/provider/XyoGatewayRunner.ts

@@ -1,9 +1,9 @@
 import type {
-  Address, Hash, Hex, Promisable,
+  Address, Hash, Promisable,
 } from '@xylabs/sdk-js'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
-  AllowedBlockPayload, AttoXL1, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionFeesBigInt,
+  AllowedBlockPayload, AttoXL1, ChainId, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionFeesBigInt,
   UnsignedHydratedTransaction,
   XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
@@ -13,7 +13,7 @@ import type { DataLakeRunner } from './DataLake.ts'
 import type { XyoGateway } from './XyoGateway.ts'
 
 export interface TransactionOptions {
-  chain?: Hex
+  chain?: ChainId
   exp?: XL1BlockNumber
   fees?: TransactionFeesBigInt
   from?: Address

package/src/provider/XyoRunner.ts

@@ -1,12 +1,16 @@
 import type { Hash, Promisable } from '@xylabs/sdk-js'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 
+import type { Provider } from '../model/index.ts'
 import type { MempoolRunner } from '../runners/index.ts'
 
 export interface XyoRunnerMethods {
   broadcastTransaction(transaction: SignedHydratedTransaction): Promisable<Hash>
 }
 
-export interface XyoRunner extends XyoRunnerMethods {
-  mempool?: MempoolRunner
+export const XyoRunnerMoniker = 'XyoRunner' as const
+export type XyoRunnerMoniker = typeof XyoRunnerMoniker
+
+export interface XyoRunner extends XyoRunnerMethods, Provider<XyoRunnerMoniker> {
+  mempool: MempoolRunner
 }

package/src/provider/viewer/XyoViewer.ts

@@ -1,29 +1,29 @@
-import type {
-  Address, Hash, Promisable,
-} from '@xylabs/sdk-js'
-import type { AttoXL1, XL1BlockRange } from '@xyo-network/xl1-protocol'
+import type { Address, Promisable } from '@xylabs/sdk-js'
+import type { AttoXL1 } from '@xyo-network/xl1-protocol'
 
-import type { Provider } from '../../model/index.ts'
+import type { ChainQualifiedConfig, Provider } from '../../model/index.ts'
 import type {
   AccountBalanceHistoryItem,
   AccountBalanceViewer,
   BlockViewer,
   BlockViewerMethods,
-  ChainViewerMethods,
   ForkViewerMethods,
   MempoolViewer,
   NetworkStakeStepRewardViewerMethods,
   StakeViewerMethods,
   StepViewer,
+  TimeSyncViewer,
   TransactionViewerMethods,
 } from '../../viewers/index.ts'
 import type { NetworkStakeViewer } from './NetworkStake/index.ts'
 
 export interface XyoViewerMethods extends
-  NetworkStakeStepRewardViewerMethods, Pick<ChainViewerMethods, 'chainId'>, BlockViewerMethods,
+  NetworkStakeStepRewardViewerMethods, BlockViewerMethods,
   TransactionViewerMethods, StakeViewerMethods, ForkViewerMethods {
-  accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AttoXL1>
-  accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AccountBalanceHistoryItem[]>
+  /** @deprecated Use .account.balance.accountBalance instead */
+  accountBalance(address: Address, config?: ChainQualifiedConfig): Promisable<AttoXL1>
+  /** @deprecated Use .account.balance.accountBalanceHistory instead */
+  accountBalanceHistory(address: Address, config?: ChainQualifiedConfig): Promisable<AccountBalanceHistoryItem[]>
 }
 
 export const XyoViewerMoniker = 'XyoViewer' as const
@@ -31,11 +31,12 @@ export type XyoViewerMoniker = typeof XyoViewerMoniker
 
 export interface XyoViewer extends Omit<BlockViewer, 'moniker'>, XyoViewerMethods,
   Omit<StakeViewerMethods, 'moniker'>, Provider<XyoViewerMoniker> {
-  account?: {
-    balance?: AccountBalanceViewer
+  account: {
+    balance: AccountBalanceViewer
   }
-  block?: BlockViewer
-  mempool?: MempoolViewer
-  networkStake?: NetworkStakeViewer
-  step?: StepViewer
+  block: BlockViewer
+  mempool: MempoolViewer
+  networkStake: NetworkStakeViewer
+  step: StepViewer
+  time: TimeSyncViewer
 }

package/src/runners/Block.ts

@@ -1,10 +1,18 @@
-import type { SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { WithHashMeta } from '@xyo-network/payload-model'
+import type {
+  BlockBoundWitness, SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+
+import type { Provider } from '../model/index.ts'
 
 export interface BlockRunnerMethods {
   produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force: true): Promise<SignedHydratedBlockWithHashMeta>
   produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: false): Promise<SignedHydratedBlockWithHashMeta | undefined>
 }
 
-export interface BlockRunner extends BlockRunnerMethods {
+export const BlockRunnerMoniker = 'BlockRunner' as const
+export type BlockRunnerMoniker = typeof BlockRunnerMoniker
 
+export interface BlockRunner extends BlockRunnerMethods, Provider<BlockRunnerMoniker> {
+  next(head: WithHashMeta<BlockBoundWitness>): Promise<SignedHydratedBlockWithHashMeta | undefined>
 }

package/src/runners/Mempool.ts

@@ -1,9 +1,14 @@
 import type { Hash } from '@xylabs/sdk-js'
 import type { SignedHydratedBlock, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 
+import type { Provider } from '../model/index.ts'
+
 export interface MempoolRunnerMethods {
   submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]>
   submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]>
 }
 
-export interface MempoolRunner extends MempoolRunnerMethods {}
+export const MempoolRunnerMoniker = 'MempoolRunner' as const
+export type MempoolRunnerMoniker = typeof MempoolRunnerMoniker
+
+export interface MempoolRunner extends MempoolRunnerMethods, Provider<MempoolRunnerMoniker> {}

package/src/services/Chain/ChainService.ts

@@ -1,6 +1,4 @@
-import type {
-  ChainContractViewer, ChainStakeViewer, ChainViewer,
-} from '../../viewers/index.ts'
+import type { ChainContractViewer, ChainStakeViewer } from '../../viewers/index.ts'
 import type { BaseChainService } from './BaseChainService.ts'
 
-export interface ChainService extends Omit<ChainContractViewer, 'moniker'>, Omit<ChainStakeViewer, 'moniker'>, Omit<ChainViewer, 'moniker'>, BaseChainService {}
+export interface ChainService extends Omit<ChainContractViewer, 'moniker'>, Omit<ChainStakeViewer, 'moniker'>, BaseChainService {}

package/src/simple/accountBalance/SimpleAccountBalanceViewer.ts

@@ -2,6 +2,7 @@ import type { Address, Hash } from '@xylabs/sdk-js'
 import {
   asHash,
   assertEx, exists, isDefined, spanRootAsync,
+  ZERO_ADDRESS,
 } from '@xylabs/sdk-js'
 import type { WithHashMeta, WithStorageMeta } from '@xyo-network/payload-model'
 import type {
@@ -16,9 +17,12 @@ import {
 import { deepCalculateFramesFromRange } from '../../block/index.ts'
 import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
 import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import type { ProviderMoniker, Qualified } from '../../model/index.ts'
+import {
+  ChainQualification, type ChainQualified, isChainQualifiedHeadConfig, isChainQualifiedRangeConfig,
+} from '../../model/index.ts'
 import type {
-  BalanceStepSummaryContext, TransfersStepSummary,
+  BalanceStepSummaryContext,
+  TransfersStepSummary,
   TransfersStepSummaryContext,
 } from '../../summary/index.ts'
 import {
@@ -26,13 +30,14 @@ import {
   transfersStepSummaryFromRange,
 } from '../../summary/index.ts'
 import {
+  AccountBalanceConfig,
   type AccountBalanceHistoryItem, type AccountBalanceViewer, AccountBalanceViewerMoniker,
   type BlockViewer,
+  BlockViewerMoniker,
 } from '../../viewers/index.ts'
 
 export interface SimpleAccountBalanceViewerParams extends CreatableProviderParams {
-  blockViewer: BlockViewer
-  context: BalanceStepSummaryContext
+  balanceSummaryContext: BalanceStepSummaryContext
   transfersSummaryContext: TransfersStepSummaryContext
 }
 
@@ -42,37 +47,38 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
   static readonly monikers = [AccountBalanceViewerMoniker]
   moniker = SimpleAccountBalanceViewer.defaultMoniker
 
-  get blockViewer(): BlockViewer {
-    return this.params.blockViewer!
+  private _blockViewer?: BlockViewer
+
+  get balanceSummaryContext() {
+    return this.params.balanceSummaryContext!
   }
 
-  get context(): BalanceStepSummaryContext {
-    return this.params.context!
+  get blockViewer() {
+    return this._blockViewer!
   }
 
-  get transfersSummaryContext(): TransfersStepSummaryContext {
+  get transfersSummaryContext() {
     return this.params.transfersSummaryContext!
   }
 
-  static override async paramsHandler(params: Partial<SimpleAccountBalanceViewerParams>) {
-    assertEx(params.blockViewer, () => 'blockViewer is required')
-    assertEx(params.context, () => 'context is required')
+  static override async paramsHandler(params: Partial<SimpleAccountBalanceViewerParams> = {}) {
     assertEx(params.transfersSummaryContext, () => 'transfersSummaryContext is required')
+    assertEx(params.balanceSummaryContext, () => 'balanceSummaryContext is required')
 
-    return { ...await super.paramsHandler(params) }
+    return await super.paramsHandler({ ...params })
   }
 
-  async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountBalances([address], headOrRange)
+  async accountBalance(address: Address, config?: AccountBalanceConfig) {
+    const balances = await this.accountBalances([address], config)
     return balances[address] ?? AttoXL1(0n)
   }
 
-  accountBalanceHistories(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Record<Address, AccountBalanceHistoryItem[]>> {
-    throw new Error('Method [accountBalanceHistories] not implemented.')
+  async accountBalanceHistories(addresses: Address[], config: AccountBalanceConfig = {}) {
+    return (await this.qualifiedAccountBalanceHistories(addresses, config))[0]
   }
 
-  async accountBalanceHistory(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AccountBalanceHistoryItem[]> {
-    const range = asRange(headOrRange)
+  async accountBalanceHistory(address: Address, config?: AccountBalanceConfig) {
+    const range = isChainQualifiedRangeConfig(config) ? config.range : undefined
     const startingRange = asXL1BlockRange(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(exists)
@@ -99,64 +105,81 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
     return result
   }
 
-  async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Record<Address, AttoXL1>> {
-    const [result] = (await this.qualifiedAccountBalances(address, _headOrRange))
+  async accountBalances(address: Address[], config?: AccountBalanceConfig) {
+    const [result] = (await this.qualifiedAccountBalances(address, config ?? {}))
     return result
   }
 
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
+  }
+
   async qualifiedAccountBalanceHistories(
     addresses: Address[],
-    headOrRange?: Hash | XL1BlockRange,
-  ): Promise<Qualified<Record<Address, AccountBalanceHistoryItem[]>>> {
-    const head = asHash(headOrRange) ?? await this.blockViewer.currentBlockHash()
-    const range = asXL1BlockRange(headOrRange) ?? asXL1BlockRange([0,
-      assertEx(
-        await this.blockViewer.blockByHash(head),
-        () => `Error: Could not find block with hash ${head}`,
-      )[0].block])
-    const qualifiedEntries: [Address, Qualified<AccountBalanceHistoryItem[]>][] = await Promise.all(addresses.map(async address => ([
+    config: AccountBalanceConfig,
+  ) {
+    const head = isChainQualifiedHeadConfig(config) ? config.head : await this.blockViewer.currentBlockHash()
+    const range = isChainQualifiedRangeConfig(config)
+      ? config.range
+      : asXL1BlockRange([0,
+          assertEx(
+            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,
       await this.qualifiedAccountBalanceHistory(address, range),
-    ])))
+    ]))) satisfies [Address, ChainQualified<AccountBalanceHistoryItem[]>][]
 
     const entries = qualifiedEntries.map(([address, [history]]) => {
       return [address, history]
     })
-    const qualifiedRange = qualifiedEntries[0][1][1]
-    const qualifiedHeadHash = qualifiedEntries[0][1][2]
+    const qualifiedRange = qualifiedEntries[0][1][1].range
+    const qualifiedHeadHash = qualifiedEntries[0][1][1].head
 
     // check for drift
-    for (const [_, [__, range, headHash]] of qualifiedEntries) {
+    for (const [_, [__, { range, head }]] of qualifiedEntries) {
       assertEx(
         range[0] === qualifiedRange[0] && range[1] === qualifiedRange[1],
         () => 'Inconsistent ranges in qualifiedAccountBalanceHistories',
       )
       assertEx(
-        headHash === qualifiedHeadHash,
+        head === qualifiedHeadHash,
         () => 'Inconsistent head hashes in qualifiedAccountBalanceHistories',
       )
     }
 
-    return [Object.fromEntries(entries), qualifiedRange, qualifiedHeadHash]
+    return [Object.fromEntries(entries), { range: qualifiedRange, head: qualifiedHeadHash }] satisfies
+      [Record<Address, AccountBalanceHistoryItem[]>, ChainQualification]
   }
 
   async qualifiedAccountBalances(
     address: Address[],
-    _headOrRange?: Hash | XL1BlockRange,
-  ): Promise<Qualified<Record<Address, AttoXL1>>> {
+    config: AccountBalanceConfig,
+  ): Promise<ChainQualified<Record<Address, AttoXL1>>> {
     return await spanRootAsync('qualifiedAccountsBalances', async () => {
       const qualifiedSummary = await balancesSummary(
-        this.context,
+        { ...this.balanceSummaryContext },
+        config,
       )
       const result: Record<Address, AttoXL1> = {}
       for (const addr of address) {
         const summaryBalance = qualifiedSummary[0][addr] ?? 0n
         result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
       }
-      return [result, qualifiedSummary[1], qualifiedSummary[2]]
+      return [result, qualifiedSummary[1]]
     })
   }
 
+  override async startHandler() {
+    await super.startHandler()
+    await Promise.all([
+      this.accountBalance(ZERO_ADDRESS),
+      this.accountBalanceHistory(ZERO_ADDRESS),
+    ])
+  }
+
   private async distillTransferHistory(address: Address, range: XL1BlockRange, max: number = 50): Promise<XL1BlockNumber[]> {
     if ((range[1] - range[0]) <= StepSizes[0] || max <= 1) {
       return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[1] - i).slice(0, max).map(n => asXL1BlockNumber(n, true))
@@ -198,7 +221,7 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
   private async qualifiedAccountBalanceHistory(
     address: Address,
     headOrRange?: Hash | XL1BlockRange,
-  ): Promise<Qualified<AccountBalanceHistoryItem[]>> {
+  ): Promise<ChainQualified<AccountBalanceHistoryItem[]>> {
     const range = asRange(headOrRange)
     const headHash = asHash(headOrRange)
     const [head] = assertEx(isDefined(headHash)
@@ -227,6 +250,6 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
         null,
         transfer] satisfies AccountBalanceHistoryItem))
     }
-    return [result, startingRange, head._hash]
+    return [result, { range: startingRange, head: head._hash }]
   }
 }

package/src/simple/block/SimpleBlockViewer.ts

@@ -3,6 +3,7 @@ import {
   assertEx,
   exists,
   isDefined,
+  isUndefined,
   spanRootAsync,
 } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
@@ -10,6 +11,7 @@ import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 import {
   asSignedHydratedBlockWithHashMeta,
   asXL1BlockNumber,
+  ChainId,
   type SignedHydratedBlockWithHashMeta,
   type XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
@@ -22,12 +24,13 @@ import type {
   ChainContextRead,
   ChainStoreRead, PayloadMap,
 } from '../../model/index.ts'
-import { findMostRecentBlock, hydratedBlockByNumber } from '../../primitives/index.ts'
+import {
+  findMostRecentBlock, hydratedBlockByNumber, readPayloadMapFromStore,
+} from '../../primitives/index.ts'
 import { HydratedCache } from '../../utils/index.ts'
 import { type BlockViewer, BlockViewerMoniker } from '../../viewers/index.ts'
 
 export interface SimpleBlockViewerParams extends CreatableProviderParams {
-  context: ChainContextRead
   finalizedArchivist: ReadArchivist
 }
 
@@ -37,27 +40,25 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
   static readonly monikers = [BlockViewerMoniker]
   moniker = SimpleBlockViewer.defaultMoniker
 
+  protected _store: ChainStoreRead | undefined
+
   private _payloadCache: PayloadMap<WithHashMeta<Payload>> | undefined
   private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithHashMeta> | undefined
 
-  get context(): ChainContextRead {
-    return this.params.context!
-  }
-
   get finalizedArchivist(): ReadArchivist {
     return this.params.finalizedArchivist!
   }
 
   protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithHashMeta> {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
-    const chainMap = this.context.store.chainMap
+    const chainMap = this.store.chainMap
     this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithHashMeta>(chainMap, async (
-      { chainMap }: ChainStoreRead,
+      store: ChainStoreRead,
       hash: Hash,
       maxDepth?: number,
       minDepth?: number,
     ) => {
-      const result = await hydrateBlock({ chainMap }, hash, maxDepth, minDepth)
+      const result = await hydrateBlock(store, hash, maxDepth, minDepth)
       return asSignedHydratedBlockWithHashMeta(result, true)
     }, 200)
     return this._signedHydratedBlockCache
@@ -69,8 +70,11 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
     return this._payloadCache
   }
 
+  protected get store() {
+    return this._store!
+  }
+
   static override async paramsHandler(params: Partial<SimpleBlockViewerParams>) {
-    assertEx(params.context, () => 'context is required')
     assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required')
 
     return { ...await super.paramsHandler(params) }
@@ -85,7 +89,18 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
 
   async blockByNumber(blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
     return await spanRootAsync('blockByNumber', async () => {
-      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(this.context, blockNumber)) ?? null
+      const head = await this.getCurrentHead()
+      if (isUndefined(head)) {
+        return null
+      }
+      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber({
+        chainId: head.chain,
+        head: () => {
+          return [head._hash, head.block]
+        },
+        store: this.store,
+        singletons: this.context.singletons,
+      } satisfies ChainContextRead, blockNumber)) ?? null
     }, this.tracer)
   }
 
@@ -121,9 +136,27 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
     }, this.tracer)
   }
 
+  chainId(): Promise<ChainId>
+  chainId(blockNumber: XL1BlockNumber): Promise<ChainId>
+  chainId(blockNumber: 'latest'): Promise<ChainId>
+  async chainId(blockNumber: XL1BlockNumber | 'latest' = 'latest'): Promise<ChainId> {
+    return await spanRootAsync('chainId', async () => {
+      const block = assertEx(
+        blockNumber === 'latest' ? await this.currentBlock() : await this.blockByNumber(blockNumber),
+        () => `Could not find block for block number ${blockNumber}`,
+      )
+      return block[0].chain
+    })
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._store = { chainMap: readPayloadMapFromStore(this.params.finalizedArchivist) }
+  }
+
   async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
     return await spanRootAsync('currentBlock', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlock]')
       const cache = this.hydratedBlockCache
       const block = await cache.get(currentHead._hash)
       if (!block) {
@@ -135,14 +168,14 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
 
   async currentBlockHash(): Promise<Hash> {
     return await spanRootAsync('currentBlockHash', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlockHash]')
       return currentHead._hash
     }, this.tracer)
   }
 
   async currentBlockNumber(): Promise<XL1BlockNumber> {
     return await spanRootAsync('currentBlockNumber', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlockNumber]')
       return asXL1BlockNumber(currentHead.block, { name: 'currentBlockNumber' })
     }, this.tracer)
   }

package/src/simple/blockValidation/SimpleBlockValidationViewer.ts

@@ -0,0 +1,126 @@
+import { exists } from '@xylabs/sdk-js'
+import {
+  asXL1BlockRange,
+  ChainId,
+  type SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+
+import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
+import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
+import { findUncles, getWindowedChain } from '../../primitives/index.ts'
+import type {
+  HydratedBlockStateValidationFunction, HydratedBlockValidationError, HydratedBlockValidationFunction,
+} from '../../validation/index.ts'
+import type {
+  AccountBalanceViewer,
+  BlockValidationConfig,
+  BlockValidationQualification,
+  BlockValidationViewer,
+} from '../../viewers/index.ts'
+import {
+  AccountBalanceViewerMoniker,
+  BlockValidationViewerMoniker, BlockViewer, BlockViewerMoniker,
+} from '../../viewers/index.ts'
+
+export interface SimpleBlockValidationViewerParams extends CreatableProviderParams {
+  maxUncleWindowSize: number
+  state?: HydratedBlockStateValidationFunction
+  value?: HydratedBlockValidationFunction
+}
+
+@creatableProvider()
+export class SimpleBlockValidationViewer extends AbstractCreatableProvider<SimpleBlockValidationViewerParams> implements BlockValidationViewer {
+  static readonly defaultMoniker = BlockValidationViewerMoniker
+  static readonly monikers = [BlockValidationViewerMoniker]
+  moniker = SimpleBlockValidationViewer.defaultMoniker
+
+  private _accountBalanceViewer!: AccountBalanceViewer
+  private _blockViewer!: BlockViewer
+  private _uncleWindowedChainCache: SignedHydratedBlockWithHashMeta[] | null = null
+
+  protected get blockViewer() {
+    return this._blockViewer
+  }
+
+  protected get maxUncleWindowSize() {
+    return this.params.maxUncleWindowSize
+  }
+
+  static override async paramsHandler(params: Partial<SimpleBlockValidationViewerParams>): Promise<SimpleBlockValidationViewerParams> {
+    return {
+      ...await super.paramsHandler(params),
+      maxUncleWindowSize: params.maxUncleWindowSize ?? 100,
+    } satisfies SimpleBlockValidationViewerParams
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
+    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
+  }
+
+  async qualifiedValidateBlock(
+    block: SignedHydratedBlockWithHashMeta,
+    config?: BlockValidationConfig,
+  ): Promise<[HydratedBlockValidationError[], BlockValidationQualification]> {
+    return (await this.qualifiedValidateBlocks([block], config))
+  }
+
+  async qualifiedValidateBlocks(
+    blocks: SignedHydratedBlockWithHashMeta[],
+    config?: BlockValidationConfig,
+  ): Promise<[HydratedBlockValidationError[], BlockValidationQualification]> {
+    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) : undefined
+    const validateState = state ? this.doValidateState.bind(this) : undefined
+
+    return [(await Promise.all([
+      validateValue?.(blocks, chainId), validateState?.(blocks, chainId),
+    ].filter(exists))).flat(), { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }]
+  }
+
+  async validateBlock(block: SignedHydratedBlockWithHashMeta, config?: BlockValidationConfig): Promise<HydratedBlockValidationError[]> {
+    return (await this.validateBlocks([block], config))
+  }
+
+  async validateBlocks(blocks: SignedHydratedBlockWithHashMeta[], config?: BlockValidationConfig): Promise<HydratedBlockValidationError[]> {
+    return (await this.qualifiedValidateBlocks(blocks, config))[0]
+  }
+
+  private async doValidateState(blocks: SignedHydratedBlockWithHashMeta[], chainId: ChainId): Promise<HydratedBlockValidationError[]> {
+    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()
+  }
+
+  private async doValidateValue(blocks: SignedHydratedBlockWithHashMeta[], chainId: ChainId): Promise<HydratedBlockValidationError[]> {
+    return (await Promise.all(blocks.map(async (block) => {
+      return await this.params.value!(
+        block,
+        chainId,
+      )
+    }))).flat()
+  }
+
+  private async updateWindowedChainCache() {
+    this._uncleWindowedChainCache = await getWindowedChain(this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? [])
+    return [...this._uncleWindowedChainCache]
+  }
+}

package/src/simple/blockValidation/index.ts

@@ -0,0 +1 @@
+export * from './SimpleBlockValidationViewer.ts'