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

package/src/config/Telemetry.ts

@@ -1,5 +1,12 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
+
+export const DefaultMetricsScrapePorts = {
+  api: 9465,
+  bridge: 9468,
+  mempool: 9466,
+  producer: 9464,
+  rewardRedemptionApi: 9467,
+}
 
 export const MetricsScrapeConfigZod = z.object({
   path: z.string().default('/metrics').register(globalRegistry, {
@@ -8,8 +15,7 @@ export const MetricsScrapeConfigZod = z.object({
     title: 'telemetry.metrics.scrape.path',
     type: 'string',
   }),
-  port: z.coerce.number().default(9464).register(globalRegistry, {
-    default: 9464,
+  port: z.coerce.number().int().positive().optional().register(globalRegistry, {
     description: 'Port for the metrics scrape endpoint',
     title: 'telemetry.metrics.scrape.port',
     type: 'number',

package/src/config/UsageMeta.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod'
+import { z } from 'zod'
 
 const DescriptionSchema = z.string()
 const TitleSchema = z.string()

package/src/config/Validation.ts

@@ -1,6 +1,5 @@
 import { AddressZod, asAddress } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const ValidationConfigZod = z.object({
   allowedRewardRedeemers: z.preprocess((val) => {

package/src/config/index.ts

@@ -1,4 +1,5 @@
 export * from './Bridge.ts'
 export * from './Config.ts'
 export { hasMongoConfig } from './storage/index.ts'
+export { DefaultMetricsScrapePorts } from './Telemetry.ts'
 export * from './UsageMeta.ts'

package/src/config/storage/Storage.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MongoConfigZod } from './driver/index.ts'
 

package/src/config/storage/driver/Mongo.ts

@@ -1,6 +1,5 @@
 import { isDefined, isUndefined } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 /**
  * Checks if the provided MongoDB configuration contains all necessary fields

package/src/eip-712/Payloads/EIP712Data.ts

@@ -1,6 +1,6 @@
 import { AsObjectFactory } from '@xylabs/sdk-js'
 import { isPayloadOfZodType, type Payload } from '@xyo-network/payload-model'
-import z from 'zod'
+import { z } from 'zod'
 
 import {
   TypedDataDomainZod, TypedDataTypesZod, TypedDataValueZod,

package/src/eip-712/Payloads/EIP712Signature.ts

@@ -1,6 +1,6 @@
 import { AsObjectFactory, HashZod } from '@xylabs/sdk-js'
 import { isPayloadOfZodType, type Payload } from '@xyo-network/payload-model'
-import z from 'zod'
+import { z } from 'zod'
 
 export const EIP712SignaturePayloadFieldsZod = z.object({
   address: z.string(),

package/src/eip-712/Types.ts

@@ -1,5 +1,5 @@
 // import type { Signer } from 'ethers/providers'
-import z from 'zod'
+import { z } from 'zod'
 
 /**
  * Typed Data Types

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './actor/index.ts'
 export * from './block/index.ts'
 export * from './ChainServiceCollectionV2.ts'
 export * from './config/index.ts'

package/src/model/ChainQualification.ts

@@ -1,7 +1,7 @@
 import { HashZod } from '@xylabs/hex'
 import { zodIsFactory } from '@xylabs/zod'
 import { XL1BlockRangeZod } from '@xyo-network/xl1-protocol'
-import z from 'zod'
+import { z } from 'zod'
 
 export const ChainQualificationZod = z.object({ head: HashZod, range: XL1BlockRangeZod })
 export type ChainQualification = z.infer<typeof ChainQualificationZod>

package/src/primitives/chain/getWindowedChain.ts

@@ -1,23 +1,42 @@
-import type { Hash } from '@xylabs/sdk-js'
+import {
+  assertEx, type Hash, isDefined, isNull,
+} from '@xylabs/sdk-js'
 import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
 
 import type { BlockViewer } from '../../viewers/index.ts'
 
-export async function getWindowedChain(blockViewer: BlockViewer, maxWindowSize: number, previousChain: SignedHydratedBlockWithHashMeta[] = []) {
-  const newBlocks: SignedHydratedBlockWithHashMeta[] = []
-  let currentBlock: SignedHydratedBlockWithHashMeta | null = await blockViewer.currentBlock()
+/**
+ * Constructs a bounded, contiguous canonical chain ending at the current head.
+ * @param blockViewer The BlockViewer to fetch blocks from
+ * @param maxWindowSize The maximum size of the windowed chain
+ * @param previousChain An optional previous chain to build upon
+ * @returns A promise that resolves to the windowed chain of blocks
+ */
+export async function getWindowedChain(blockViewer: BlockViewer, maxWindowSize: number, previousChain: SignedHydratedBlockWithHashMeta[] = []):
+Promise<SignedHydratedBlockWithHashMeta[]> {
+  const newChain: SignedHydratedBlockWithHashMeta[] = []
+  const previousChainByHash = new Map<Hash, SignedHydratedBlockWithHashMeta>(previousChain.map(block => [block[0]._hash, block]))
+  const head = await blockViewer.currentBlock()
+  let currentBlock: SignedHydratedBlockWithHashMeta | null = head
   console.log('[getWindowedChain] Current Block:', currentBlock?.[0]._hash)
-  const head = currentBlock
-  while (currentBlock !== null && currentBlock[0].block >= head[0].block) {
-    newBlocks.unshift(currentBlock)
+  while (currentBlock !== null && newChain.length < maxWindowSize) {
+    const currentBlockNumber = currentBlock[0].block
+    const nextBlock = newChain[0]
+    if (isDefined(nextBlock)) {
+      const nextBlockNumber = nextBlock[0].block
+      assertEx(
+        currentBlockNumber === nextBlockNumber - 1,
+        () => `[getWindowedChain] Non-monotonic block sequence detected: current=${currentBlockNumber}, next=${nextBlockNumber}`,
+      )
+    }
+    assertEx(
+      currentBlockNumber <= head[0].block,
+      () => `[getWindowedChain] Current block number (${currentBlockNumber}) exceeds head block number (${head[0].block})`,
+    )
+    newChain.unshift(currentBlock)
     const previousBlockHash: Hash | null = 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)
+    if (isNull(previousBlockHash)) break
+    currentBlock = previousChainByHash.get(previousBlockHash) ?? await blockViewer.blockByHash(previousBlockHash)
   }
   return newChain
 }

package/src/primitives/rewards/networkStakeStepRewardPositionWeight.ts

@@ -1,8 +1,8 @@
-import { type StepIdentity } from '@xyo-network/xl1-protocol'
+import { type StepIdentity, XYO_NETWORK_STAKING_ADDRESS } from '@xyo-network/xl1-protocol'
 
 import type { StakedChainContextRead } from '../../model/index.ts'
 import type { BlockViewer } from '../../viewers/index.ts'
-import { externalBlockRangeFromStep } from '../chain/time/index.ts'
+import { externalBlockRangeFromStep } from '../chain/index.ts'
 import { weightedStakeForRangeByPosition } from '../stake/index.ts'
 
 export async function networkStakeStepRewardPositionWeight(
@@ -15,6 +15,7 @@ export async function networkStakeStepRewardPositionWeight(
     context,
     blockViewer,
     await externalBlockRangeFromStep(context, blockViewer, stepContext),
+    XYO_NETWORK_STAKING_ADDRESS,
     position,
   )
   return result

package/src/primitives/stake/allStakersForStep.ts

@@ -3,7 +3,7 @@ import type { StepIdentity } from '@xyo-network/xl1-protocol'
 
 import type { StakedChainContextRead } from '../../model/index.ts'
 import type { BlockViewer } from '../../viewers/index.ts'
-import { externalBlockRangeFromXL1BlockRange } from '../chain/time/index.ts'
+import { externalBlockRangeFromXL1BlockRange } from '../chain/index.ts'
 import { stepBlockRange } from '../step/index.ts'
 import { allStakersForRange } from './allStakersForRange.ts'
 

package/src/primitives/stake/weightedStakeForRangeByPosition.ts

@@ -1,3 +1,4 @@
+import type { Address } from '@xylabs/sdk-js'
 import { isDefined } from '@xylabs/sdk-js'
 import { asBlockNumber, type BlockRange } from '@xyo-network/xl1-protocol'
 
@@ -9,6 +10,7 @@ export async function weightedStakeForRangeByPosition(
   context: StakedChainContextRead,
   blockViewer: BlockViewer,
   externalRange: BlockRange, // first to last block of step
+  staked?: Address,
   positionId?: number,
 ): Promise<bigint> {
   const cacheKey = isDefined(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`
@@ -22,6 +24,12 @@ export async function weightedStakeForRangeByPosition(
       )).toSorted((a, b) => a.time - b.time)
       let currentTime = externalRange[0]
       let currentStake = 0n // await activeStakeAtTimeByPosition(chainEvents, pos.staked, currentTime - 1, position)
+
+      // if not staking the desired address, return 0n
+      if (isDefined(staked) && mergedEvents[0].args.staked !== staked) {
+        return 0n
+      }
+
       for (const event of mergedEvents) {
         if (event.time > currentTime) {
           // Add the weighted stake for the period between the range start or previous event and this event
@@ -44,9 +52,9 @@ export async function weightedStakeForRangeByPosition(
         weightedStakeSum += currentStake * BigInt(externalRange[1] - currentTime)
       }
     } else {
-      const positionCount = await context.stake.stakeEvents.positionCount(externalRange)
+      const positionCount = await context.stake.stakeEvents.positionCount([0, externalRange[1]])
       for (let pos = 0; pos < positionCount; pos++) {
-        weightedStakeSum += await weightedStakeForRangeByPosition(context, blockViewer, externalRange, pos)
+        weightedStakeSum += await weightedStakeForRangeByPosition(context, blockViewer, externalRange, staked, pos)
       }
     }
     return weightedStakeSum

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/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

@@ -44,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
 

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

@@ -24,13 +24,14 @@ import {
 
 export interface SimpleBlockValidationViewerParams extends CreatableProviderParams {
   maxUncleWindowSize: number
+  protocol?: HydratedBlockValidationFunction
   state?: HydratedBlockStateValidationFunction
-  value?: HydratedBlockValidationFunction
 }
 
 @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
 
@@ -77,11 +78,11 @@ export class SimpleBlockValidationViewer extends AbstractCreatableProvider<Simpl
     const [headBlock] = await this.blockViewer.currentBlock()
     const chainId = headBlock.chain
 
-    const validateValue = value ? this.doValidateValue.bind(this) : undefined
+    const validateProtocol = value ? this.doValidateProtocol.bind(this) : undefined
     const validateState = state ? this.doValidateState.bind(this) : undefined
 
     return [(await Promise.all([
-      validateValue?.(blocks, chainId), validateState?.(blocks, chainId),
+      validateProtocol?.(blocks, chainId), validateState?.(blocks, chainId),
     ].filter(exists))).flat(), { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }]
   }
 
@@ -93,13 +94,24 @@ export class SimpleBlockValidationViewer extends AbstractCreatableProvider<Simpl
     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) {
-      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}]`)
+      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!(
@@ -110,15 +122,6 @@ export class SimpleBlockValidationViewer extends AbstractCreatableProvider<Simpl
     }))).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/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/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

@@ -17,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
 }

package/src/simple/finalization/SimpleFinalizationRunner.ts

@@ -0,0 +1,45 @@
+import { type Hash } from '@xylabs/sdk-js'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import { type SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+import {
+  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
+} from '../../CreatableProvider/index.ts'
+import { ChainStoreWrite } from '../../model/index.ts'
+import { payloadMapFromStore } from '../../primitives/index.ts'
+import { type FinalizationRunner, FinalizationRunnerMoniker } from '../../runners/index.ts'
+
+export interface SimpleFinalizationRunnerParams extends CreatableProviderParams {
+  finalizedArchivist: ArchivistInstance
+}
+
+@creatableProvider()
+export class SimpleFinalizationRunner extends AbstractCreatableProvider<SimpleFinalizationRunnerParams> implements FinalizationRunner {
+  static readonly defaultMoniker = FinalizationRunnerMoniker
+  static readonly dependencies = []
+  static readonly monikers = [FinalizationRunnerMoniker]
+  moniker = SimpleFinalizationRunner.defaultMoniker
+
+  protected _store: ChainStoreWrite | undefined
+
+  protected get store() {
+    return this._store!
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._store = { chainMap: payloadMapFromStore(this.params.finalizedArchivist) }
+  }
+
+  async finalizeBlock(block: SignedHydratedBlockWithHashMeta): Promise<Hash> {
+    return (await this.finalizeBlocks([block]))[0]
+  }
+
+  async finalizeBlocks(blocks: SignedHydratedBlockWithHashMeta[]): Promise<Hash[]> {
+    const sortedBlocks = blocks.toSorted((a, b) => a[0].block - b[0].block)
+    const payloads = sortedBlocks.flatMap(block => [...block[1], block[0]].map(p => ([p._hash, p] as [Hash, WithStorageMeta<Payload>])))
+    await this.store.chainMap.setMany(payloads)
+    return sortedBlocks.map(b => b[0]._hash)
+  }
+}