@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/src/simple/block/SimpleBlockViewer.ts

@@ -1,231 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  assertEx, exists, isUndefined,
-} from '@xylabs/sdk-js'
-import type {
-  Payload, ReadArchivist, WithHashMeta,
-} from '@xyo-network/sdk-js'
-import {
-  asSignedHydratedBlockWithHashMeta, asSignedHydratedBlockWithStorageMeta, asXL1BlockNumber,
-  BlockContextRead,
-  BlockRate, BlockViewer, BlockViewerMoniker, ChainContextRead,
-  ChainId, DataLakeViewer, DataLakeViewerMoniker, FinalizationViewer, FinalizationViewerMoniker, type SignedHydratedBlockWithHashMeta,
-  SignedHydratedBlockWithStorageMeta, SingleTimeConfig, TimeDurations, type XL1BlockNumber, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { hydrateBlock } from '../../block/index.ts'
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import { LruCacheMap } from '../../driver/index.ts'
-import { ChainStoreRead } from '../../model/index.ts'
-import {
-  addDataLakePayloads,
-  addDataLakePayloadsToPayloads,
-  calculateBlockRate, calculateStepSizeRate, calculateTimeRate, hydratedBlockByNumber,
-} from '../../primitives/index.ts'
-import { HydratedCache } from '../../utils/index.ts'
-
-/** Parameters for SimpleBlockViewer. */
-export interface SimpleBlockViewerParams extends CreatableProviderParams {
-  finalizedArchivist: ReadArchivist
-}
-
-/** SimpleBlockViewer implementation. */
-@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
-  protected dataLakeViewer?: DataLakeViewer
-  protected finalizationViewer!: FinalizationViewer
-  protected payloadCache = new LruCacheMap<Hash, WithHashMeta<Payload>>({ max: 10_000 })
-  protected signedHydratedBlockWithDataLakePayloadsCache = new LruCacheMap<Hash, SignedHydratedBlockWithHashMeta>({ max: 2000, ttl: 1000 * 60 * 60 })
-
-  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithStorageMeta> | undefined
-
-  get finalizedArchivist(): ReadArchivist {
-    return this.params.finalizedArchivist
-  }
-
-  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithStorageMeta> {
-    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
-    const context = this.getBlockContextRead()
-    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithStorageMeta>(context, async (
-      context,
-      hash: Hash,
-      maxDepth?: number,
-      minDepth?: number,
-    ) => {
-      const result = await hydrateBlock(context, hash, maxDepth, minDepth)
-      return asSignedHydratedBlockWithStorageMeta(result, true)
-    }, 20_000)
-    return this._signedHydratedBlockCache
-  }
-
-  protected get store() {
-    return this._store!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleBlockViewerParams>) {
-    return {
-      ...await super.paramsHandler(params),
-      finalizedArchivist: assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required'),
-    } satisfies SimpleBlockViewerParams
-  }
-
-  async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
-    return await this.spanAsync('blockByHash', async () => {
-      const cachedBlock = this.signedHydratedBlockWithDataLakePayloadsCache.get(hash)
-      if (cachedBlock) {
-        return cachedBlock
-      }
-
-      const cache = this.hydratedBlockCache
-      const block = await cache.get(hash)
-      const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []]
-      if (result) {
-        this.signedHydratedBlockWithDataLakePayloadsCache.set(hash, result)
-      }
-      return result
-    }, { ...this.context, timeBudgetLimit: 100 })
-  }
-
-  async blockByNumber(blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
-    return await this.spanAsync('blockByNumber', async () => {
-      const chainContext = await this.getChainContextRead()
-      if (isUndefined(chainContext.head)) {
-        return null
-      }
-      return await this.blockByNumberWithContext(chainContext, blockNumber)
-    }, { ...this.context, timeBudgetLimit: 100 })
-  }
-
-  async blocksByHash(hash: Hash, limit = 50): Promise<SignedHydratedBlockWithHashMeta[]> {
-    return await this.spanAsync('blocksByHash', async () => {
-      assertEx(limit > 0, () => 'limit must be greater than 0')
-      assertEx(limit <= 100, () => 'limit must be less than 100')
-      const blocks: SignedHydratedBlockWithHashMeta[] = []
-      let current = await this.blockByHash(hash)
-      while (current && blocks.length < limit) {
-        blocks.push(current)
-        const previousHash = current[0].previous
-        if (previousHash === null) break
-        current = await this.blockByHash(previousHash)
-      }
-      return blocks.map(b => asSignedHydratedBlockWithHashMeta(b, true))
-    }, { ...this.context, timeBudgetLimit: 300 })
-  }
-
-  async blocksByNumber(blockNumber: XL1BlockNumber, limit = 50): Promise<SignedHydratedBlockWithHashMeta[]> {
-    return await this.spanAsync('blocksByNumber', async () => {
-      assertEx(limit > 0, () => 'limit must be greater than 0')
-      assertEx(limit <= 100, () => 'limit must be less than 100')
-      const chainContext = await this.getChainContextRead()
-      if (isUndefined(chainContext.head)) {
-        return []
-      }
-      const blocks: SignedHydratedBlockWithHashMeta[] = []
-      let current = await this.blockByNumberWithContext(chainContext, blockNumber)
-      while (current && blocks.length < limit) {
-        blocks.push(current)
-        if (current[0].block === 0) break
-        const previousNumber = asXL1BlockNumber(current[0].block - 1, true)
-        current = await this.blockByNumberWithContext(chainContext, previousNumber)
-      }
-      return blocks.map(b => asSignedHydratedBlockWithHashMeta(b, true))
-    }, this.context)
-  }
-
-  chainId(): Promise<ChainId>
-  chainId(blockNumber: XL1BlockNumber): Promise<ChainId>
-  chainId(blockNumber: 'latest'): Promise<ChainId>
-  async chainId(blockNumber: XL1BlockNumber | 'latest' = 'latest'): Promise<ChainId> {
-    return await this.spanAsync('chainId', async () => {
-      return blockNumber === 'latest' ? (await this.finalizationViewer.headBlock()).chain : assertEx((await this.blockByNumber(blockNumber)), () => `Block not found [${blockNumber}]`)[0].chain
-    }, this.context)
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this.dataLakeViewer = await this.locator.tryGetInstance<DataLakeViewer>(DataLakeViewerMoniker)
-    this.finalizationViewer = await this.locator.getInstance<FinalizationViewer>(FinalizationViewerMoniker)
-    this._store = { chainMap: this.params.finalizedArchivist }
-  }
-
-  async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
-    const [result] = await addDataLakePayloads(await this.finalizationViewer.head(), this.dataLakeViewer)
-    return result
-  }
-
-  async currentBlockHash(): Promise<Hash> {
-    return await this.finalizationViewer.headHash()
-  }
-
-  async currentBlockNumber(): Promise<XL1BlockNumber> {
-    return await this.finalizationViewer.headNumber()
-  }
-
-  async payloadByHash(hash: Hash): Promise<WithHashMeta<Payload> | null> {
-    const [payload] = await this.payloadsByHash([hash])
-    return payload ?? null
-  }
-
-  async payloadsByHash(hashes: Hash[]): Promise<WithHashMeta<Payload>[]> {
-    let remainingHashes = [...hashes]
-    const cachedPayloads = this.payloadCache.getMany(remainingHashes)
-    const cachedHashes = new Set(cachedPayloads.map(p => p._hash))
-    remainingHashes = remainingHashes.filter(h => !cachedHashes.has(h))
-    const finalizedPayloads = remainingHashes.length > 0
-      ? await this.finalizedArchivist.get(remainingHashes)
-      : []
-    const [resultPayloads] = await addDataLakePayloadsToPayloads(hashes, [...cachedPayloads, ...finalizedPayloads.filter(exists)], this.dataLakeViewer)
-    resultPayloads.map((payload) => {
-      this.payloadCache.set(payload._hash, payload)
-    })
-    return resultPayloads
-  }
-
-  async rate(range: XL1BlockRange, timeUnit?: keyof TimeDurations): Promise<BlockRate> {
-    return await calculateBlockRate(this, range, timeUnit)
-  }
-
-  async stepSizeRate(start: XL1BlockNumber, stepIndex: number, count = 1, timeUnit?: keyof TimeDurations): Promise<BlockRate> {
-    return await calculateStepSizeRate(this, start, stepIndex, count, timeUnit)
-  }
-
-  async timeDurationRate(
-    timeConfig: SingleTimeConfig,
-    startBlockNumber?: XL1BlockNumber,
-    timeUnit?: keyof TimeDurations,
-    toleranceMs?: number,
-    maxAttempts?: number,
-  ): Promise<BlockRate> {
-    return await calculateTimeRate(this, timeConfig, startBlockNumber, timeUnit, toleranceMs, maxAttempts)
-  }
-
-  protected getBlockContextRead(): BlockContextRead {
-    return {
-      ...this.context,
-      chainMap: this.store.chainMap,
-    }
-  }
-
-  protected async getChainContextRead(): Promise<ChainContextRead> {
-    return {
-      ...this.getBlockContextRead(),
-      head: (await this.finalizationViewer.head())[0],
-    }
-  }
-
-  private async blockByNumberWithContext(
-    chainContext: ChainContextRead,
-    blockNumber: XL1BlockNumber,
-  ): Promise<SignedHydratedBlockWithHashMeta | null> {
-    const block = asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(chainContext, blockNumber)) ?? null
-    const [result] = block ? await addDataLakePayloads(block, this.dataLakeViewer) : [null, []]
-    return result
-  }
-}

package/src/simple/block/index.ts

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

package/src/simple/blockInvalidation/SimpleBlockInvalidationViewer.ts

@@ -1,197 +0,0 @@
-import { assertEx, Promisable } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  AccountBalanceViewer,
-  AccountBalanceViewerMoniker,
-  asXL1BlockRange,
-  BlockInvalidationConfig,
-  BlockInvalidationQualification,
-  BlockInvalidationViewer,
-  BlockInvalidationViewerMoniker,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  ChainId,
-  HydratedBlockStateValidationFunction,
-  HydratedBlockValidationError,
-  HydratedBlockValidationFunction,
-  isChainQualifiedHeadConfig,
-  isHydratedBlock,
-  SignedHydratedBlock,
-  type SignedHydratedBlockWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import { findUncles, getWindowedChain } from '../../primitives/index.ts'
-
-/** Parameters for SimpleBlockInvalidationViewer. */
-export interface SimpleBlockInvalidationViewerParams extends CreatableProviderParams {
-  maxUncleWindowSize?: number
-  state?: HydratedBlockStateValidationFunction
-  value?: HydratedBlockValidationFunction
-}
-
-/** SimpleBlockInvalidationViewer implementation. */
-@creatableProvider()
-export class SimpleBlockInvalidationViewer extends AbstractCreatableProvider<SimpleBlockInvalidationViewerParams> implements BlockInvalidationViewer {
-  static readonly defaultMoniker = BlockInvalidationViewerMoniker
-  static readonly dependencies = [AccountBalanceViewerMoniker, BlockViewerMoniker, ChainContractViewerMoniker]
-  static readonly monikers = [BlockInvalidationViewerMoniker]
-  moniker = SimpleBlockInvalidationViewer.defaultMoniker
-
-  private _accountBalanceViewer!: AccountBalanceViewer
-  private _blockViewer!: BlockViewer
-  private _chainContractViewer!: ChainContractViewer
-  private _uncleWindowedChainCache: SignedHydratedBlockWithHashMeta[] | null = null
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  protected get chainContractViewer() {
-    return this._chainContractViewer
-  }
-
-  protected get maxUncleWindowSize() {
-    return this.params.maxUncleWindowSize!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleBlockInvalidationViewerParams>): Promise<SimpleBlockInvalidationViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      value: params.value,
-      state: params.state,
-      maxUncleWindowSize: params.maxUncleWindowSize ?? 100,
-    } satisfies SimpleBlockInvalidationViewerParams
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-  }
-
-  async invalidateBlock(
-    block: SignedHydratedBlock,
-    config?: BlockInvalidationConfig,
-  ): Promise<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta> {
-    return (await this.invalidateBlocks([block], config))[0]
-  }
-
-  async invalidateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockInvalidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedInvalidateBlocks(blocks, config))[0]
-  }
-
-  async invalidateUncle(
-    blocks: SignedHydratedBlock[],
-    config?: BlockInvalidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedInvalidateUncle(blocks, config))[0]
-  }
-
-  async qualifiedInvalidateBlock(
-    block: SignedHydratedBlockWithHashMeta,
-    config?: BlockInvalidationConfig,
-  ): Promise<[HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta, BlockInvalidationQualification]> {
-    const result = (await this.qualifiedInvalidateBlocks([block], config))
-    return [result[0][0], result[1]]
-  }
-
-  async qualifiedInvalidateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockInvalidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockInvalidationQualification]> {
-    const { value, state } = config ?? {
-      shape: true, links: true, state: true, head: undefined,
-    }
-
-    const blocksWithMeta = await Promise.all(blocks.map(b => Promise.all([PayloadBuilder.addHashMeta(b[0]), PayloadBuilder.addHashMeta(b[1])])))
-
-    const head = isChainQualifiedHeadConfig(config)
-      ? assertEx(
-          (await this.blockViewer.blockByHash(config.head))?.[0],
-          () => `Specified a head that is not in the chain [${config.head}]`,
-        )
-      : undefined
-
-    const headBlock = head ?? (await this.blockViewer.currentBlock())[0]
-
-    const validateProtocol = value ? this.doInvalidateProtocol.bind(this) : undefined
-    const validateState = state ? this.doInvalidateState.bind(this) : undefined
-
-    const chainIdAtBlockNumber = (blockNumber: XL1BlockNumber) => this.chainContractViewer.chainIdAtBlockNumber(blockNumber)
-
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }
-    const [protocolResults, stateResults] = await Promise.all([
-      validateProtocol?.(blocksWithMeta, chainIdAtBlockNumber), validateState?.(blocksWithMeta, chainIdAtBlockNumber),
-    ])
-    const blockResults = blocksWithMeta.map((r, i) => {
-      const errors = []
-      if (protocolResults && !isHydratedBlock(protocolResults[i])) {
-        errors.push(...(protocolResults[i]))
-      }
-      if (stateResults && !isHydratedBlock(stateResults[i])) {
-        errors.push(...(stateResults[i]))
-      }
-      return errors.length === 0 ? r : errors
-    })
-    return [blockResults, qualification]
-  }
-
-  qualifiedInvalidateUncle(
-    _blocks: SignedHydratedBlock[],
-    _config?: BlockInvalidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockInvalidationQualification]> {
-    throw new Error('Method not implemented.')
-  }
-
-  private async doInvalidateProtocol(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | HydratedBlockValidationError[])[]> {
-    return (await Promise.all(blocks.map(async (block) => {
-      const errors = await this.params.value!(
-        this.context,
-        block,
-        chainIdAtBlockNumber,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async doInvalidateState(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | 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) => {
-      const errors = await this.params.state!(
-        {
-          ...this.context, chainIdAtBlockNumber, accountBalance: this._accountBalanceViewer,
-        },
-        block,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async updateWindowedChainCache() {
-    this._uncleWindowedChainCache = await getWindowedChain(this.context, this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? [])
-    return [...this._uncleWindowedChainCache]
-  }
-}

package/src/simple/blockInvalidation/index.ts

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

package/src/simple/blockReward/SimpleBlockRewardViewer.ts

@@ -1,27 +0,0 @@
-import { Promisable } from '@xylabs/sdk-js'
-import {
-  AttoXL1, BlockRewardViewer, BlockRewardViewerMoniker, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { rewardFromBlockNumber } from '../../primitives/index.ts'
-
-/** Parameters for SimpleBlockRewardViewer. */
-export interface SimpleBlockRewardViewerParams extends CreatableProviderParams {}
-
-/** SimpleBlockRewardViewer implementation. */
-@creatableProvider()
-export class SimpleBlockRewardViewer extends AbstractCreatableProvider<SimpleBlockRewardViewerParams> implements BlockRewardViewer {
-  static readonly defaultMoniker = BlockRewardViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [BlockRewardViewerMoniker]
-  moniker = SimpleBlockRewardViewer.defaultMoniker
-
-  allowedRewardForBlock(block: XL1BlockNumber): Promisable<AttoXL1> {
-    return rewardFromBlockNumber(
-      block,
-    )
-  }
-}

package/src/simple/blockReward/index.ts

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

package/src/simple/blockValidation/SimpleBlockValidationViewer.ts

@@ -1,194 +0,0 @@
-import { assertEx, Promisable } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  AccountBalanceViewer,
-  AccountBalanceViewerMoniker,
-  asXL1BlockRange,
-  BlockValidationConfig,
-  BlockValidationQualification,
-  BlockValidationViewer,
-  BlockValidationViewerMoniker,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  ChainId,
-  HydratedBlockStateValidationFunction,
-  HydratedBlockValidationError,
-  HydratedBlockValidationFunction,
-  isChainQualifiedHeadConfig,
-  isHydratedBlock,
-  SignedHydratedBlock,
-  type SignedHydratedBlockWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import { findUncles, getWindowedChain } from '../../primitives/index.ts'
-
-/** Parameters for SimpleBlockValidationViewer. */
-export interface SimpleBlockValidationViewerParams extends CreatableProviderParams {
-  maxUncleWindowSize?: number
-  protocol?: HydratedBlockValidationFunction
-  state?: HydratedBlockStateValidationFunction
-}
-
-/** SimpleBlockValidationViewer implementation. */
-@creatableProvider()
-export class SimpleBlockValidationViewer extends AbstractCreatableProvider<SimpleBlockValidationViewerParams> implements BlockValidationViewer {
-  static readonly defaultMoniker = BlockValidationViewerMoniker
-  static readonly dependencies = [AccountBalanceViewerMoniker, BlockViewerMoniker, ChainContractViewerMoniker]
-  static readonly monikers = [BlockValidationViewerMoniker]
-  moniker = SimpleBlockValidationViewer.defaultMoniker
-
-  private _accountBalanceViewer!: AccountBalanceViewer
-  private _blockViewer!: BlockViewer
-  private _chainContractViewer!: ChainContractViewer
-  private _uncleWindowedChainCache: SignedHydratedBlockWithHashMeta[] | null = null
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  protected get chainContractViewer() {
-    return this._chainContractViewer
-  }
-
-  protected get maxUncleWindowSize() {
-    return this.params.maxUncleWindowSize!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleBlockValidationViewerParams>): Promise<SimpleBlockValidationViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      protocol: params.protocol,
-      state: params.state,
-      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)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-  }
-
-  async qualifiedValidateBlock(
-    block: SignedHydratedBlockWithHashMeta,
-    config?: BlockValidationConfig,
-  ): Promise<[HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta, BlockValidationQualification]> {
-    const result = (await this.qualifiedValidateBlocks([block], config))
-    return [result[0][0], result[1]]
-  }
-
-  async qualifiedValidateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockValidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockValidationQualification]> {
-    const { value, state } = config ?? {
-      shape: true, links: true, state: true, head: undefined,
-    }
-
-    const blocksWithMeta = await Promise.all(blocks.map(b => Promise.all([PayloadBuilder.addHashMeta(b[0]), PayloadBuilder.addHashMeta(b[1])])))
-
-    const head = isChainQualifiedHeadConfig(config)
-      ? assertEx(
-          (await this.blockViewer.blockByHash(config.head))?.[0],
-          () => `Specified a head that is not in the chain [${config.head}]`,
-        )
-      : undefined
-
-    const headBlock = head ?? (await this.blockViewer.currentBlock())[0]
-
-    const validateProtocol = value ? this.doValidateProtocol.bind(this) : undefined
-    const validateState = state ? this.doValidateState.bind(this) : undefined
-
-    const chainIdAtBlockNumber = (blockNumber: XL1BlockNumber) => this.chainContractViewer.chainIdAtBlockNumber(blockNumber)
-
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }
-    const [protocolResults, stateResults] = await Promise.all([
-      validateProtocol?.(blocksWithMeta, chainIdAtBlockNumber), validateState?.(blocksWithMeta, chainIdAtBlockNumber),
-    ])
-    const blockResults = blocksWithMeta.map((r, i) => {
-      const errors = []
-      if (protocolResults && !isHydratedBlock(protocolResults[i])) {
-        errors.push(...(protocolResults[i]))
-      }
-      if (stateResults && !isHydratedBlock(stateResults[i])) {
-        errors.push(...(stateResults[i]))
-      }
-      return errors.length === 0 ? r : errors
-    })
-    return [blockResults, qualification]
-  }
-
-  qualifiedValidateUncle(
-    _blocks: SignedHydratedBlock[],
-    _config?: BlockValidationConfig,
-  ): Promise<[(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[], BlockValidationQualification]> {
-    throw new Error('Method not implemented.')
-  }
-
-  async validateBlock(block: SignedHydratedBlock, config?: BlockValidationConfig): Promise<HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta> {
-    return (await this.validateBlocks([block], config))[0]
-  }
-
-  async validateBlocks(
-    blocks: SignedHydratedBlock[],
-    config?: BlockValidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedValidateBlocks(blocks, config))[0]
-  }
-
-  async validateUncle(
-    blocks: SignedHydratedBlock[],
-    config?: BlockValidationConfig,
-  ): Promise<(HydratedBlockValidationError[] | SignedHydratedBlockWithHashMeta)[]> {
-    return (await this.qualifiedValidateUncle(blocks, config))[0]
-  }
-
-  private async doValidateProtocol(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | HydratedBlockValidationError[])[]> {
-    return (await Promise.all(blocks.map(async (block) => {
-      const errors = await this.params.protocol!(
-        this.context,
-        block,
-        chainIdAtBlockNumber,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async doValidateState(
-    blocks: SignedHydratedBlockWithHashMeta[],
-    chainIdAtBlockNumber: (blockNumber: XL1BlockNumber) => Promisable<ChainId>,
-  ): Promise<(SignedHydratedBlockWithHashMeta | 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) => {
-      const errors = await this.params.state!(
-        {
-          ...this.context, chainIdAtBlockNumber, accountBalance: this._accountBalanceViewer,
-        },
-        block,
-      )
-      return (errors.length === 0) ? block : errors
-    })))
-  }
-
-  private async updateWindowedChainCache() {
-    this._uncleWindowedChainCache = await getWindowedChain(this.context, this.blockViewer, this.maxUncleWindowSize, this._uncleWindowedChainCache ?? [])
-    return [...this._uncleWindowedChainCache]
-  }
-}

package/src/simple/blockValidation/index.ts

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