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

package/src/primitives/uncle/findUncles.ts

@@ -0,0 +1,75 @@
+import {
+  assertEx,
+  exists, type Hash,
+} from '@xylabs/sdk-js'
+import { isTransactionBoundWitness, type SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+import type { BaseContext } from '../../model/index.ts'
+
+function blocksToChains(blocks: SignedHydratedBlockWithHashMeta[]) {
+  const chains: SignedHydratedBlockWithHashMeta[][] = []
+  const map = new Map<Hash, SignedHydratedBlockWithHashMeta>()
+  for (const block of blocks) {
+    map.set(block[0]._hash, block)
+  }
+  for (const block of blocks) {
+    let uncle: SignedHydratedBlockWithHashMeta[] = [block]
+    let previous = block[0].previous ? map.get(block[0].previous) : undefined
+    while (previous) {
+      if (previous[0].block === (uncle[0][0].block - 1)) {
+        uncle.unshift(previous)
+        previous = previous[0].previous ? map.get(previous[0].previous) : undefined
+      } else {
+        // block number sequence is off
+        uncle = []
+        break
+      }
+    }
+    if (uncle.length > 0) {
+      chains.push(uncle)
+    }
+  }
+  return chains
+}
+
+function toValidUncle(
+  _context: BaseContext,
+  finalizedWindowedChain: SignedHydratedBlockWithHashMeta[],
+  possibleUncle: SignedHydratedBlockWithHashMeta[],
+) {
+  const finalizedWindowStartBlockNumber = finalizedWindowedChain.at(0)?.[0].block ?? -1
+  const finalizedHead = assertEx(finalizedWindowedChain.at(-1), () => 'finalizedWindowedChain is empty')
+  // prune the chain to match the finalized head
+
+  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) {
+    // uncle does not build on finalized head (block number mismatch)
+    return
+  }
+  if (prunedPossibleUncle[0][0].previous !== finalizedHead[0]._hash) {
+    // uncle does not build on finalized head (previous hash mismatch)
+    return
+  }
+  const allUncleTransactions = prunedPossibleUncle.flatMap(b => b[1]).filter(isTransactionBoundWitness)
+  const allFinalizedTransactions = finalizedWindowedChain.flatMap(b => b[1]).filter(isTransactionBoundWitness)
+  const txPossiblyBeforeWindow = allUncleTransactions.find(tx => tx.nbf < finalizedWindowStartBlockNumber)
+  if (txPossiblyBeforeWindow) {
+    // uncle has a transaction that is valid before the finalized window
+    return
+  }
+  const txExistsInWindow = allUncleTransactions.find(tx => allFinalizedTransactions.find(finalTx => finalTx._hash === tx._hash))
+  if (txExistsInWindow) {
+    // uncle has a transaction that is already in the finalized window
+    return
+  }
+  return prunedPossibleUncle
+}
+
+export function findUncles(context: BaseContext, finalizedWindowedChain: SignedHydratedBlockWithHashMeta[], blocks: SignedHydratedBlockWithHashMeta[]) {
+  return blocksToChains(blocks).map(chain => toValidUncle(context, finalizedWindowedChain, chain)).filter(exists)
+}

package/src/primitives/uncle/index.ts

@@ -0,0 +1,3 @@
+export * from './findBestUncle.ts'
+export * from './findUncles.ts'
+export * from './scoreUncle.ts'

package/src/primitives/uncle/scoreUncle.ts

@@ -0,0 +1,6 @@
+import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+export function scoreUncle(finalizedWindowedChain: SignedHydratedBlockWithHashMeta[], blocks: SignedHydratedBlockWithHashMeta[]) {
+  // TODO: More than length check
+  return blocks.length
+}

package/src/provider/signer/XyoSigner.ts

@@ -7,6 +7,9 @@ import type {
   TransactionFeesBigInt,
 } from '@xyo-network/xl1-protocol'
 
+export const XyoSignerMoniker = 'XyoSigner' as const
+export type XyoSignerMoniker = typeof XyoSignerMoniker
+
 export interface XyoSigner {
   address(): Promisable<Address>
   // The tx passed in must have all the payloads (on and off chain) in the payloads array

package/src/provider/viewer/XyoViewer.ts

@@ -1,9 +1,7 @@
-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,
@@ -22,8 +20,10 @@ import type { NetworkStakeViewer } from './NetworkStake/index.ts'
 export interface XyoViewerMethods extends
   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

package/src/runners/Finalization.ts

@@ -0,0 +1,15 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+import type { Provider } from '../model/index.ts'
+
+export interface FinalizationRunnerMethods {
+  finalizeBlocks(blocks: SignedHydratedBlockWithHashMeta[]): Promise<Hash[]>
+}
+
+export const FinalizationRunnerMoniker = 'FinalizationRunner' as const
+export type FinalizationRunnerMoniker = typeof FinalizationRunnerMoniker
+
+export interface FinalizationRunner extends FinalizationRunnerMethods, Provider<FinalizationRunnerMoniker> {
+  finalizeBlock(block: SignedHydratedBlockWithHashMeta): Promise<Hash>
+}

package/src/runners/index.ts

@@ -1,2 +1,3 @@
 export * from './Block.ts'
+export * from './Finalization.ts'
 export * from './Mempool.ts'

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,7 +17,9 @@ import {
 import { deepCalculateFramesFromRange } from '../../block/index.ts'
 import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
 import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import type { Qualified } from '../../model/index.ts'
+import {
+  ChainQualification, type ChainQualified, isChainQualifiedHeadConfig, isChainQualifiedRangeConfig,
+} from '../../model/index.ts'
 import type {
   BalanceStepSummaryContext,
   TransfersStepSummary,
@@ -27,6 +30,7 @@ import {
   transfersStepSummaryFromRange,
 } from '../../summary/index.ts'
 import {
+  AccountBalanceConfig,
   type AccountBalanceHistoryItem, type AccountBalanceViewer, AccountBalanceViewerMoniker,
   type BlockViewer,
   BlockViewerMoniker,
@@ -40,6 +44,7 @@ export interface SimpleAccountBalanceViewerParams extends CreatableProviderParam
 @creatableProvider()
 export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<SimpleAccountBalanceViewerParams> implements AccountBalanceViewer {
   static readonly defaultMoniker = AccountBalanceViewerMoniker
+  static readonly dependencies = [BlockViewerMoniker]
   static readonly monikers = [AccountBalanceViewerMoniker]
   moniker = SimpleAccountBalanceViewer.defaultMoniker
 
@@ -64,17 +69,17 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
     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)
@@ -101,8 +106,8 @@ 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
   }
 
@@ -113,57 +118,69 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
 
   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.balanceSummaryContext,
+        { ...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))
@@ -205,7 +222,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)
@@ -234,6 +251,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

@@ -7,12 +7,14 @@ import {
   spanRootAsync,
 } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
-import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
 import {
   asSignedHydratedBlockWithHashMeta,
+  asSignedHydratedBlockWithStorageMeta,
   asXL1BlockNumber,
   ChainId,
   type SignedHydratedBlockWithHashMeta,
+  SignedHydratedBlockWithStorageMeta,
   type XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
 
@@ -24,11 +26,11 @@ import type {
   ChainContextRead,
   ChainStoreRead, PayloadMap,
 } from '../../model/index.ts'
-import {
-  findMostRecentBlock, hydratedBlockByNumber, readPayloadMapFromStore,
-} from '../../primitives/index.ts'
+import { hydratedBlockByNumber, readPayloadMapFromStore } from '../../primitives/index.ts'
 import { HydratedCache } from '../../utils/index.ts'
-import { type BlockViewer, BlockViewerMoniker } from '../../viewers/index.ts'
+import {
+  type BlockViewer, BlockViewerMoniker, FinalizationViewer, FinalizationViewerMoniker,
+} from '../../viewers/index.ts'
 
 export interface SimpleBlockViewerParams extends CreatableProviderParams {
   finalizedArchivist: ReadArchivist
@@ -37,36 +39,38 @@ export interface SimpleBlockViewerParams extends CreatableProviderParams {
 @creatableProvider()
 export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockViewerParams> implements BlockViewer {
   static readonly defaultMoniker = BlockViewerMoniker
+  static readonly dependencies = [FinalizationViewerMoniker]
   static readonly monikers = [BlockViewerMoniker]
   moniker = SimpleBlockViewer.defaultMoniker
 
   protected _store: ChainStoreRead | undefined
+  protected finalizationViewer!: FinalizationViewer
 
-  private _payloadCache: PayloadMap<WithHashMeta<Payload>> | undefined
-  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithHashMeta> | undefined
+  private _payloadCache: PayloadMap<WithStorageMeta<Payload>> | undefined
+  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithStorageMeta> | undefined
 
   get finalizedArchivist(): ReadArchivist {
     return this.params.finalizedArchivist!
   }
 
-  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithHashMeta> {
+  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithStorageMeta> {
     if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
     const chainMap = this.store.chainMap
-    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithHashMeta>(chainMap, async (
+    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithStorageMeta>(chainMap, async (
       store: ChainStoreRead,
       hash: Hash,
       maxDepth?: number,
       minDepth?: number,
     ) => {
       const result = await hydrateBlock(store, hash, maxDepth, minDepth)
-      return asSignedHydratedBlockWithHashMeta(result, true)
+      return asSignedHydratedBlockWithStorageMeta(result, true)
     }, 200)
     return this._signedHydratedBlockCache
   }
 
-  protected get payloadCache(): PayloadMap<WithHashMeta<Payload>> {
+  protected get payloadCache(): PayloadMap<WithStorageMeta<Payload>> {
     if (this._payloadCache) return this._payloadCache
-    this._payloadCache = new LruCacheMap<Hash, WithHashMeta<Payload>>({ max: 10_000 })
+    this._payloadCache = new LruCacheMap<Hash, WithStorageMeta<Payload>>({ max: 10_000 })
     return this._payloadCache
   }
 
@@ -89,7 +93,7 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
 
   async blockByNumber(blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
     return await spanRootAsync('blockByNumber', async () => {
-      const head = await this.getCurrentHead()
+      const [head] = await this.currentBlock()
       if (isUndefined(head)) {
         return null
       }
@@ -151,36 +155,23 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
 
   override async createHandler() {
     await super.createHandler()
+    this.finalizationViewer = await this.locator.getInstance<FinalizationViewer>(FinalizationViewerMoniker)
     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 [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 assertEx(block, () => 'Could not find current block')
-    }, this.tracer)
+    return await this.finalizationViewer.head()
   }
 
   async currentBlockHash(): Promise<Hash> {
-    return await spanRootAsync('currentBlockHash', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlockHash]')
-      return currentHead._hash
-    }, this.tracer)
+    return await this.finalizationViewer.headHash()
   }
 
   async currentBlockNumber(): Promise<XL1BlockNumber> {
-    return await spanRootAsync('currentBlockNumber', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlockNumber]')
-      return asXL1BlockNumber(currentHead.block, { name: 'currentBlockNumber' })
-    }, this.tracer)
+    return await this.finalizationViewer.headNumber()
   }
 
-  async payloadByHash(hash: Hash): Promise<WithHashMeta<Payload> | null> {
+  async payloadByHash(hash: Hash): Promise<WithStorageMeta<Payload> | null> {
     const cachedPayload = await this.payloadCache.get(hash)
     if (cachedPayload) {
       return cachedPayload
@@ -193,7 +184,7 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
     }
   }
 
-  async payloadsByHash(hashes: Hash[]): Promise<WithHashMeta<Payload>[]> {
+  async payloadsByHash(hashes: Hash[]): Promise<WithStorageMeta<Payload>[]> {
     let remainingHashes = [...hashes]
     const cachedPayloads = await this.payloadCache.getMany(remainingHashes)
     const cachedHashes = new Set(cachedPayloads.map(p => p._hash))
@@ -203,9 +194,4 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
       : []
     return [...cachedPayloads, ...remainingPayloads.filter(exists)]
   }
-
-  protected async getCurrentHead() {
-    const chainArchivist = this.finalizedArchivist
-    return await findMostRecentBlock(chainArchivist)
-  }
 }

package/src/simple/blockReward/SimpleBlockRewardViewer.ts

@@ -19,6 +19,7 @@ export interface SimpleBlockRewardViewerParams extends CreatableProviderParams {
 @creatableProvider()
 export class SimpleBlockRewardViewer extends AbstractCreatableProvider<SimpleBlockRewardViewerParams> implements BlockRewardViewer {
   static readonly defaultMoniker = BlockRewardViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [BlockRewardViewerMoniker]
   moniker = SimpleBlockRewardViewer.defaultMoniker
 

package/src/simple/blockValidation/SimpleBlockValidationViewer.ts

@@ -0,0 +1,129 @@
+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
+  protocol?: HydratedBlockValidationFunction
+  state?: HydratedBlockStateValidationFunction
+}
+
+@creatableProvider()
+export class SimpleBlockValidationViewer extends AbstractCreatableProvider<SimpleBlockValidationViewerParams> implements BlockValidationViewer {
+  static readonly defaultMoniker = BlockValidationViewerMoniker
+  static readonly dependencies = [AccountBalanceViewerMoniker, BlockViewerMoniker]
+  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 validateProtocol = value ? this.doValidateProtocol.bind(this) : undefined
+    const validateState = state ? this.doValidateState.bind(this) : undefined
+
+    return [(await Promise.all([
+      validateProtocol?.(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 doValidateProtocol(blocks: SignedHydratedBlockWithHashMeta[], chainId: ChainId): Promise<HydratedBlockValidationError[]> {
+    return (await Promise.all(blocks.map(async (block) => {
+      return await this.params.protocol!(
+        block,
+        chainId,
+      )
+    }))).flat()
+  }
+
+  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) {
+      this.logger?.warn(JSON.stringify({ uncles, blocks }, null, 2))
+      this.logger?.warn(JSON.stringify(windowedUncleChain, null, 2))
+      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}, ${blocks.length}]`)
+    }
+    return (await Promise.all(uncles[0].map(async (block) => {
+      return await this.params.state!(
+        block,
+        chainId,
+        { accountBalance: this._accountBalanceViewer },
+      )
+    }))).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'

package/src/simple/chainStake/SimpleStakeViewer.ts

@@ -21,6 +21,7 @@ export interface SimpleChainStakeParams extends CreatableProviderParams {
 @creatableProvider()
 export class SimpleStakeViewer extends AbstractCreatableProvider<SimpleChainStakeParams> implements StakeViewer {
   static readonly defaultMoniker = StakeViewerMoniker
+  static readonly dependencies = [StakeEventsViewerMoniker]
   static readonly monikers = [StakeViewerMoniker]
   moniker = SimpleStakeViewer.defaultMoniker
 

package/src/simple/datalake/AbstractSimpleDataLake.ts

@@ -14,7 +14,8 @@ MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>> extends
   map: TMap
 }
 
-export class AbstractSimpleDataLake<TParams extends AbstractSimpleDataLakeParams = AbstractSimpleDataLakeParams> extends AbstractCreatableProvider<TParams> {
+export abstract class AbstractSimpleDataLake<TParams extends AbstractSimpleDataLakeParams = AbstractSimpleDataLakeParams> extends
+  AbstractCreatableProvider<TParams> {
   get allowedSchemas(): Schema[] | undefined {
     return this.params.allowedSchemas
   }

package/src/simple/datalake/SimpleDataLakeRunner.ts

@@ -16,6 +16,7 @@ export interface DataLakeRunnerParams extends DataLakeViewerParams<MapType<Hash,
 export class SimpleDataLakeRunner<TParams extends DataLakeRunnerParams> extends
   AbstractSimpleDataLake<TParams> implements DataLakeRunner {
   static readonly defaultMoniker = DataLakeRunnerMoniker
+  static readonly dependencies = []
   static readonly monikers = [DataLakeRunnerMoniker]
   moniker = SimpleDataLakeRunner.defaultMoniker
 

package/src/simple/datalake/SimpleDataLakeViewer.ts

@@ -1,5 +1,4 @@
 import type { Hash } from '@xylabs/sdk-js'
-import { isAnyPayload } from '@xyo-network/payload-model'
 
 import { creatableProvider } from '../../CreatableProvider/index.ts'
 import type { MapTypeRead } from '../../map/index.ts'
@@ -18,6 +17,7 @@ export interface DataLakeViewerParams<TMap extends MapTypeRead<Hash, DataLakeDat
 export class SimpleDataLakeViewer<TParams extends DataLakeViewerParams = DataLakeViewerParams>
   extends AbstractSimpleDataLake<TParams> implements DataLakeViewer {
   static readonly defaultMoniker = DataLakeViewerMoniker
+  static readonly dependencies = []
   static readonly monikers = [DataLakeViewerMoniker]
   moniker = SimpleDataLakeViewer.defaultMoniker
 }