@xyo-network/chain-services 1.16.26 → 1.17.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.16.26",
+  "version": "1.17.0",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -48,17 +48,17 @@
     "@xyo-network/boundwitness-model": "~5.2.10",
     "@xyo-network/boundwitness-validator": "~5.2.10",
     "@xyo-network/boundwitness-wrapper": "~5.2.10",
-    "@xyo-network/chain-analyze": "~1.16.26",
-    "@xyo-network/chain-modules": "~1.16.26",
-    "@xyo-network/chain-protocol": "~1.16.26",
-    "@xyo-network/chain-utils": "~1.16.26",
+    "@xyo-network/chain-analyze": "~1.17.0",
+    "@xyo-network/chain-modules": "~1.17.0",
+    "@xyo-network/chain-protocol": "~1.17.0",
+    "@xyo-network/chain-utils": "~1.17.0",
     "@xyo-network/payload-builder": "~5.2.10",
     "@xyo-network/payload-model": "~5.2.10",
     "@xyo-network/typechain": "~4.0.10",
     "@xyo-network/xl1-protocol": "~1.14.15",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.26",
-    "@xyo-network/xl1-validation": "~1.16.26",
-    "@xyo-network/xl1-wrappers": "~1.16.26",
+    "@xyo-network/xl1-protocol-sdk": "~1.17.0",
+    "@xyo-network/xl1-validation": "~1.17.0",
+    "@xyo-network/xl1-wrappers": "~1.17.0",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
     "lru-cache": "~11.2.2",
@@ -72,12 +72,12 @@
     "@xylabs/vitest-extended": "~5.0.46",
     "@xyo-network/account": "~5.2.10",
     "@xyo-network/account-model": "~5.2.10",
-    "@xyo-network/chain-validation": "~1.16.26",
+    "@xyo-network/chain-validation": "~1.17.0",
     "@xyo-network/wallet": "~5.2.10",
     "eslint": "^9.39.1",
     "tslib": "~2.8.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.13",
+    "vitest": "~4.0.14",
     "vitest-mock-extended": "~3.1.0",
     "web3-types": "~1.10.0"
   },

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -10,7 +10,6 @@ import {
   balancesSummary,
   BalanceStepSummaryContext,
   BlockViewer,
-  EventingChainBlockNumberIteratorService,
   SimpleAccountBalanceViewer,
   TransfersStepSummaryContext,
 } from '@xyo-network/xl1-protocol-sdk'
@@ -30,9 +29,8 @@ export const BaseAccountBalanceServiceParamsZod = z.object({
 export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
   blockViewer: BlockViewer
   chainArchivist: ReadArchivist
-  chainIterator: EventingChainBlockNumberIteratorService
   context: BalanceStepSummaryContext
-  transferContext: TransfersStepSummaryContext
+  transfersSummaryContext: TransfersStepSummaryContext
 }
 
 @creatable()
@@ -93,7 +91,7 @@ export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceSer
   override async createHandler() {
     this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
       context: this.params.context,
-      transferContext: this.params.transferContext,
+      transfersSummaryContext: this.params.transfersSummaryContext,
       blockViewer: this.blockViewer,
     })
   }

package/src/AccountBalance/accountBalanceServiceFromArchivist.ts

@@ -1,12 +1,13 @@
 import type { Hash } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
-import { findMostRecentBlock } from '@xyo-network/chain-protocol'
 import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
 import type { ChainId } from '@xyo-network/xl1-protocol'
 import { StepSizes } from '@xyo-network/xl1-protocol'
 import type { AccountBalanceViewer, BalancesStepSummary } from '@xyo-network/xl1-protocol-sdk'
-import { LruCacheMap, readPayloadMapFromStore } from '@xyo-network/xl1-protocol-sdk'
+import {
+  findMostRecentBlock, LruCacheMap, readPayloadMapFromStore,
+} from '@xyo-network/xl1-protocol-sdk'
 import { Semaphore } from 'async-mutex'
 
 import { BaseAccountBalanceService } from './BaseAccountBalanceService.ts'

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -15,7 +15,7 @@ import {
   Transfer, XYO_STEP_REWARD_ADDRESS,
 } from '@xyo-network/xl1-protocol'
 import {
-  AccountBalanceViewer, BlockProducerService, Config, PendingTransactionsService, StakeIntentService, TimeSyncViewer,
+  AccountBalanceViewer, BlockProducerService, Config, MempoolViewer, StakeIntentService, TimeSyncViewer,
 } from '@xyo-network/xl1-protocol-sdk'
 import z from 'zod'
 
@@ -49,7 +49,7 @@ export const BaseBlockProducerServiceParamsZod = z.object({
 
 export interface BaseBlockProducerServiceParams extends XyoValidatorParams<Pick<Config, 'producer'>> {
   balanceService: AccountBalanceViewer
-  pendingTransactionsService: PendingTransactionsService
+  pendingTransactionsService: MempoolViewer
   rejectedTransactionsArchivist: ArchivistInstance
   rewardAddress: Address
   time: TimeSyncViewer
@@ -94,8 +94,8 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return assertEx(this.params.balanceService, () => 'balanceService is required')
   }
 
-  protected get chainArchivist() {
-    return assertEx(this.params.chainArchivist, () => 'chainArchivist is required')
+  protected get blockViewer() {
+    return assertEx(this.params.blockViewer, () => 'blockViewer is required')
   }
 
   protected get chainId() {
@@ -203,7 +203,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       const { block: previousBlock } = assertEx(asBlockBoundWitness(head), () => 'Invalid head block')
       const nextBlock = previousBlock + 1
       const nextBlockTransactionsStart = Date.now()
-      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, BaseBlockProducerService.DefaultBlockSize)
+      const nextBlockTransactions = await this.pendingTransactionsService.pendingTransactions({ limit: BaseBlockProducerService.DefaultBlockSize })
       const nextBlockTransactionsDuration = Date.now() - nextBlockTransactionsStart
       if (nextBlockTransactionsDuration > 200) {
         this.logger?.warn(`[Slow] Fetched ${nextBlockTransactions.length} pending transactions in ${nextBlockTransactionsDuration}ms}`)

package/src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts

@@ -1,24 +1,30 @@
-import type { Hex } from '@xylabs/sdk-js'
+import type { Hash, Hex } from '@xylabs/sdk-js'
 import {
   assertEx,
   isDefined, isNull, isUndefined,
 } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
+import type {
+  BlockBoundWitness, SignedHydratedBlockWithHashMeta, XL1BlockNumber,
+} from '@xyo-network/xl1-protocol'
 import {
-  asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashMeta,
+  asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta, asSignedHydratedBlockWithHashMeta, asXL1BlockNumber, isBlockBoundWitnessWithHashMeta,
 } from '@xyo-network/xl1-protocol'
 import type {
-  ChainIteratorServiceEventData, EventingChainBlockNumberIteratorService, PayloadMapRead,
+  BlockViewer,
+  ChainIteratorServiceEventData,
+  ChainStoreRead,
+  PayloadMapRead,
 } from '@xyo-network/xl1-protocol-sdk'
+import { hydrateBlock } from '@xyo-network/xl1-protocol-sdk'
 import { LRUCache } from 'lru-cache'
 
 import { BaseService } from '../BaseService.ts'
 import type { XyoChainIteratorParams } from './model/index.ts'
 
 export class ChainBlockNumberIterationService extends BaseService<XyoChainIteratorParams, ChainIteratorServiceEventData>
-  implements EventingChainBlockNumberIteratorService {
+  implements BlockViewer {
   protected _blocksByBlockNumber = new LRUCache<number, WithStorageMeta<BlockBoundWitness>>({ max: 10_000 })
   protected _currentHead: WithStorageMeta<BlockBoundWitness> | undefined
 
@@ -26,6 +32,56 @@ export class ChainBlockNumberIterationService extends BaseService<XyoChainIterat
 
   get chainMap(): PayloadMapRead<WithStorageMeta<Payload>> { return assertEx(this.params.chainMap) }
 
+  get chainStoreRead() {
+    return { chainMap: this.chainMap } satisfies ChainStoreRead
+  }
+
+  async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
+    return asSignedHydratedBlockWithHashMeta(await hydrateBlock(this.chainStoreRead, hash)) ?? null
+  }
+
+  async blockByNumber(block: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
+    return asSignedHydratedBlockWithHashMeta(await this.get(block)) ?? null
+  }
+
+  async blocksByHash(hash: Hash, limit: number = 100): Promise<SignedHydratedBlockWithHashMeta[]> {
+    const results: SignedHydratedBlockWithHashMeta[] = []
+    let currentBlock = await this.blockByHash(hash)
+    while (currentBlock !== null && (isUndefined(limit) || results.length < limit)) {
+      results.push(currentBlock)
+      const previousHash = currentBlock[0].previous
+      if (isNull(previousHash)) break
+      currentBlock = await this.blockByHash(previousHash)
+    }
+    return results
+  }
+
+  async blocksByNumber(blockNumber: XL1BlockNumber, limit: number = 100): Promise<SignedHydratedBlockWithHashMeta[]> {
+    const results: SignedHydratedBlockWithHashMeta[] = []
+    let currentBlock = await this.blockByNumber(blockNumber)
+    while (currentBlock !== null && (isUndefined(limit) || results.length < limit)) {
+      results.push(currentBlock)
+      if (currentBlock[0].block === 0) break
+      const previousNumber = asXL1BlockNumber(currentBlock[0].block - 1, true)
+      currentBlock = await this.blockByNumber(previousNumber)
+    }
+    return results
+  }
+
+  async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
+    return assertEx(await this.blockByHash(await this.currentBlockHash()), () => 'Current block not found')
+  }
+
+  async currentBlockHash(): Promise<Hash> {
+    const head = assertEx(await this.head(), () => 'Head is not set')
+    return head._hash
+  }
+
+  async currentBlockNumber(): Promise<XL1BlockNumber> {
+    const head = assertEx(await this.head(), () => 'Head is not set')
+    return head.block
+  }
+
   async get(block: number): Promise<WithStorageMeta<BlockBoundWitness>> {
     const head = await this.head()
     // if(isUndefined(head)) return undefined

package/src/ChainService/Evm/Evm.ts

@@ -1,4 +1,6 @@
-import type { Address } from '@xylabs/sdk-js'
+import type {
+  Address, Hex, Promisable,
+} from '@xylabs/sdk-js'
 import {
   assertEx, toAddress, toEthAddress,
 } from '@xylabs/sdk-js'
@@ -13,7 +15,7 @@ import type { BaseServiceParams } from '../../model/index.ts'
 
 export interface EvmChainServiceParams extends BaseServiceParams {
   contract: StakedXyoChain
-  id: Address
+  id: Hex
   runner: ContractRunner
 }
 
@@ -21,91 +23,91 @@ export interface EvmChainServiceParams extends BaseServiceParams {
  * A class that represents a chain stake as backed by an EVM smart contract
  */
 export class EvmChainService extends BaseService<EvmChainServiceParams> implements ChainService {
-  get chainId(): Address {
-    return assertEx(this.params.id)
-  }
-
-  get contract() {
-    if (this.params.contract === undefined) {
-      this.params.contract = StakedXyoChainFactory.connect(
-        toEthAddress(this.chainId),
-        this.params.runner,
-      ) as StakedXyoChain
-    }
-    return assertEx(this.params.contract)
-  }
-
   get runner(): ContractRunner {
     return assertEx(this.params.runner)
   }
 
   async active(): Promise<bigint> {
-    return await this.contract.active()
+    return await (await this.contract()).active()
   }
 
   async activeByStaked(staked: Address): Promise<bigint> {
-    return await this.contract.activeByAddressStaked(getAddress(toEthAddress(staked)))
+    return await (await this.contract()).activeByAddressStaked(getAddress(toEthAddress(staked)))
   }
 
   async activeByStaker(address: Address): Promise<bigint> {
-    return await this.contract.activeByStaker(getAddress(toEthAddress(address)))
+    return await (await this.contract()).activeByStaker(getAddress(toEthAddress(address)))
   }
 
   async addStake(staked: Address, amount: bigint): Promise<boolean> {
-    const result = await this.contract.addStake(getAddress(toEthAddress(staked)), amount)
+    const result = await (await this.contract()).addStake(getAddress(toEthAddress(staked)), amount)
     await result.wait()
     return true
   }
 
+  chainId(): Promisable<Hex> {
+    return assertEx(this.params.id)
+  }
+
+  async contract() {
+    if (this.params.contract === undefined) {
+      this.params.contract = StakedXyoChainFactory.connect(
+        toEthAddress(await this.chainId()),
+        this.params.runner,
+      ) as StakedXyoChain
+    }
+    return assertEx(this.params.contract)
+  }
+
   async forkedAtBlockNumber(): Promise<bigint> {
-    return await this.contract.forkedAtBlockNumber()
+    return await (await this.contract()).forkedAtBlockNumber()
   }
 
   async forkedAtHash(): Promise<bigint> {
-    return await this.contract.forkedAtHash()
+    return await (await this.contract()).forkedAtHash()
   }
 
   async forkedChainId(): Promise<Address> {
-    return toAddress(await this.contract.forkedChainId())
+    return toAddress(await (await this.contract()).forkedChainId())
   }
 
   async minWithdrawalBlocks(): Promise<bigint> {
-    return await this.contract.minWithdrawalBlocks()
+    return await (await this.contract()).minWithdrawalBlocks()
   }
 
   async pending(): Promise<bigint> {
-    return await this.contract.pending()
+    return await (await this.contract()).pending()
   }
 
   async pendingByStaker(staker: Address): Promise<bigint> {
-    return await this.contract.pendingByStaker(getAddress(toEthAddress(staker)))
+    return await (await this.contract()).pendingByStaker(getAddress(toEthAddress(staker)))
   }
 
   async removeStake(slot: bigint): Promise<boolean> {
-    const result = await this.contract.removeStake(slot)
+    const result = await (await this.contract()).removeStake(slot)
     await result.wait()
     return true
   }
 
   async rewardsContract(): Promise<string> {
-    return await this.contract.rewardsContract()
+    return await (await this.contract()).rewardsContract()
   }
 
   async stakingTokenAddress(): Promise<string> {
-    return await this.contract.stakingTokenAddress()
+    return await (await this.contract()).stakingTokenAddress()
   }
 
   async withdrawStake(slot: bigint): Promise<boolean> {
-    const result = await this.contract.withdrawStake(slot)
+    const result = await (await this.contract()).withdrawStake(slot)
     await result.wait()
     return true
   }
 
   async withdrawn(): Promise<bigint> {
-    return await this.contract.withdrawn()
+    return await (await this.contract()).withdrawn()
   }
 
   async withdrawnByStaker(staker: string): Promise<bigint> {
-    return await this.contract.withdrawnByStaker(getAddress(staker))
+    return await (await this.contract()).withdrawnByStaker(getAddress(staker))
   }
 }

package/src/ChainService/Memory/Memory.ts

@@ -1,4 +1,6 @@
-import type { Address } from '@xylabs/sdk-js'
+import type {
+  Address, Hex, Promisable,
+} from '@xylabs/sdk-js'
 import {
   assertEx, toAddress, ZERO_ADDRESS,
 } from '@xylabs/sdk-js'
@@ -8,20 +10,16 @@ import { BaseService } from '../../BaseService.ts'
 import type { BaseServiceParams } from '../../model/index.ts'
 
 export interface MemoryChainServiceParams extends BaseServiceParams<Pick<Config, 'producer'>> {
-  chainId: Address
+  chainId: Hex
 }
 
 /**
  * A class that represents a chain stake as backed in memory
  */
 export class MemoryChainService extends BaseService<MemoryChainServiceParams> implements ChainService {
-  protected _chainId: Address | undefined
+  protected _chainId: Hex | undefined
   protected _simulatedStake: bigint = 1n
 
-  get chainId(): Address {
-    return assertEx(this._chainId, () => 'Chain ID not set')
-  }
-
   async active(): Promise<bigint> {
     return await Promise.resolve(this._simulatedStake)
   }
@@ -38,6 +36,10 @@ export class MemoryChainService extends BaseService<MemoryChainServiceParams> im
     return await Promise.resolve(true)
   }
 
+  chainId(): Promisable<Hex> {
+    return assertEx(this._chainId, () => 'Chain ID not set')
+  }
+
   override createHandler(): void {
     const { minStake = 1 } = this.params.config.producer ?? {}
     this._simulatedStake = BigInt(minStake)

package/src/ChainValidator/XyoValidator.ts

@@ -3,14 +3,14 @@ import {
   Promisable,
 } from '@xylabs/sdk-js'
 import { AccountInstance } from '@xyo-network/account-model'
-import { ArchivistInstance, ReadArchivist } from '@xyo-network/archivist-model'
+import { ArchivistInstance } from '@xyo-network/archivist-model'
 import {
   BlockBoundWitness,
   ChainId,
   SignedHydratedTransactionWithStorageMeta,
 } from '@xyo-network/xl1-protocol'
 import {
-  BlockRewardService, ElectionService, HydratedBlockStateValidationFunction, StakeIntentService,
+  BlockRewardService, BlockViewer, ElectionService, HydratedBlockStateValidationFunction, StakeIntentService,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import { BaseService } from '../BaseService.ts'
@@ -19,7 +19,7 @@ import { Validator } from './model/index.ts'
 
 export interface XyoValidatorParams<TConfig extends EmptyObject = EmptyObject> extends BaseServiceParams<TConfig> {
   account: AccountInstance
-  chainArchivist: ReadArchivist
+  blockViewer: BlockViewer
   chainId: ChainId
   electionService: ElectionService
   pendingBundledTransactionsArchivist: ArchivistInstance
@@ -38,8 +38,8 @@ export class XyoValidator<TParams extends XyoValidatorParams = XyoValidatorParam
     return assertEx(this.params.account, () => 'account is required')
   }
 
-  protected get chainArchivist() {
-    return assertEx(this.params.chainArchivist, () => 'chainArchivist is required')
+  protected get blockViewer() {
+    return assertEx(this.params.blockViewer, () => 'blockViewer is required')
   }
 
   protected get chainInfo() {
@@ -66,7 +66,7 @@ export class XyoValidator<TParams extends XyoValidatorParams = XyoValidatorParam
   async validatePendingTransaction(hydratedTransaction: SignedHydratedTransactionWithStorageMeta): Promise<boolean> {
     const [tx] = hydratedTransaction
     // Ensure not confirmed already (replay attack)
-    if ((await this.chainArchivist.get([tx._hash])).length > 0) return false
+    if ((await this.blockViewer.blockByHash(tx._hash)) !== undefined) return false
     // TODO: Ensure transaction is valid (double spend, has voucher, has required stake, etc.)
     // TODO: Ensure validator stake is valid
     return await Promise.resolve(true)

package/src/Election/BaseElectionService.ts

@@ -5,22 +5,23 @@ import { hexToLast4BytesInt, shuffleWithSeed } from '@xyo-network/chain-utils'
 import { WithHashMeta } from '@xyo-network/payload-model'
 import { BlockBoundWitness } from '@xyo-network/xl1-protocol'
 import type {
-  ChainBlockNumberIteratorService, ChainStakeViewer, ElectionService, StakeIntentService,
+  BlockViewer,
+  ChainStakeViewer, ElectionService, StakeIntentService,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import { BaseService } from '../BaseService.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
 export interface BaseElectionServicesParams extends BaseServiceParams {
-  chainIterator?: ChainBlockNumberIteratorService
+  blockViewer?: BlockViewer
   chainStakeViewer?: ChainStakeViewer
   stakeIntentService?: StakeIntentService
 }
 
 @creatable()
 export class BaseElectionService extends BaseService<BaseElectionServicesParams> implements ElectionService {
-  get chainIterator() {
-    return assertEx(this.params.chainIterator, () => 'No chain iterator')
+  get blockViewer() {
+    return assertEx(this.params.blockViewer, () => 'No block viewer')
   }
 
   get chainStakeViewer() {

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -7,7 +7,6 @@ import {
 } from '@xylabs/sdk-js'
 import { MemoryArchivist } from '@xyo-network/archivist-memory'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
-import { findMostRecentBlock } from '@xyo-network/chain-protocol'
 import {
   Payload, PayloadBundle, Sequence, WithStorageMeta,
 } from '@xyo-network/payload-model'
@@ -17,7 +16,9 @@ import {
   SignedHydratedTransactionWithStorageMeta,
   XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
-import { PendingTransactionsService } from '@xyo-network/xl1-protocol-sdk'
+import {
+  findMostRecentBlock, MempoolViewer, PendingTransactionsOptions,
+} from '@xyo-network/xl1-protocol-sdk'
 import { TransactionJsonSchemaValidator, validateTransaction } from '@xyo-network/xl1-validation'
 import { Mutex } from 'async-mutex'
 
@@ -35,7 +36,7 @@ export interface BasePendingTransactionsServiceParams extends BaseServiceParams
 }
 
 @creatable()
-export class BasePendingTransactionsService extends BaseService<BasePendingTransactionsServiceParams> implements PendingTransactionsService {
+export class BasePendingTransactionsService extends BaseService<BasePendingTransactionsServiceParams> implements MempoolViewer {
   private static readonly MutexPriority = {
     /**
      * Priority for inserting new transactions
@@ -142,12 +143,12 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
     })
   }
 
-  async getPendingTransactions(head: Hash, limit: number): Promise<SignedHydratedTransactionWithStorageMeta[]> {
+  async pendingTransactions({ limit = 100 }: PendingTransactionsOptions = {}): Promise<SignedHydratedTransactionWithStorageMeta[]> {
     return await this.spanAsync('getPendingTransactions', async () => {
     // Acquires an exclusive mutex to ensure no race conditions while accessing pending transactions.
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
         // Find the supplied head
-        let [lastHead] = filterAs(await this.chainArchivist.get([head]), x => asBlockBoundWitnessWithHashMeta(x))
+        let lastHead = (filterAs(await this.chainArchivist.next({ limit: 100 }), x => asBlockBoundWitnessWithHashMeta(x))).at(-1)
         if (isUndefined(lastHead)) return []
 
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash)

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -19,9 +19,9 @@ import {
 } from '@xyo-network/xl1-protocol'
 import {
   asChainIndexingServiceStateWithStorageMeta,
+  BlockViewer,
   ChainIndexingServiceState, ChainIndexingServiceStateSchema, ChainStakeViewer,
   Config,
-  EventingChainBlockNumberIteratorService,
   isChainIndexingServiceState,
   readPayloadMapFromStore,
   StakeIntentService,
@@ -34,8 +34,8 @@ import { BaseService } from '../BaseService.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
 export interface XyoStakeIntentServiceParams extends BaseServiceParams<Pick<Config, 'producer'>> {
+  blockViewer?: BlockViewer
   chainArchivist?: ArchivistInstance
-  chainIterator?: EventingChainBlockNumberIteratorService
   chainStakeViewer?: ChainStakeViewer
   stakeIntentStateArchivist?: ArchivistInstance
 }
@@ -65,12 +65,12 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
   protected _stakeCache = new LRUCache<Address, bigint>({ max: STAKE_CACHE_MAX_ENTRIES })
   protected _updateMutex = new Mutex()
 
-  protected get chainArchivist() {
-    return assertEx(this.params.chainArchivist, () => 'chainArchivist not set')
+  protected get blockViewer() {
+    return assertEx(this.params.blockViewer, () => 'blockViewer not set')
   }
 
-  protected get chainIterator() {
-    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
+  protected get chainArchivist() {
+    return assertEx(this.params.chainArchivist, () => 'chainArchivist not set')
   }
 
   protected get chainStakeViewer() {
@@ -82,13 +82,9 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
   }
 
   override async createHandler() {
-    this.chainIterator.on('headUpdated', async () => {
-      await this.updateIndex()
-    })
-    const head = await this.chainIterator.head()
+    const head = await this.blockViewer.currentBlock()
     if (isUndefined(head)) return
-    const headHash = await PayloadBuilder.hash(head)
-    await this.recoverState(headHash)
+    await this.recoverState(head[0]._hash)
   }
 
   async getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>> {
@@ -208,7 +204,7 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
     }
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync('updateIndex', async () => {
-        const currentHead = await this.chainIterator.head()
+        const currentHead = (await this.blockViewer.currentBlock())[0]
         if (isUndefined(currentHead)) return
         return await timeBudget('XyoStakeIntentService.updateIndex', console, async () => {
           const currentHeadHash = currentHead._hash

package/src/Time/BaseTimeSyncService.ts

@@ -1,18 +1,16 @@
 import { creatable, EmptyObject } from '@xylabs/sdk-js'
-import { ReadArchivist } from '@xyo-network/archivist-model'
 import { TimeDomain, TimePayload } from '@xyo-network/xl1-protocol'
 import {
-  EventingChainBlockNumberIteratorService, SimpleTimeSyncViewer, TimeSyncViewer,
+  BlockViewer,
+  SimpleTimeSyncViewer, TimeSyncViewer,
 } from '@xyo-network/xl1-protocol-sdk'
 import { Provider } from 'ethers'
 
 import { BaseService } from '../BaseService.ts'
-import { blockViewerFromChainIteratorAndArchivist } from '../blockViewerFromChainIteratorAndArchivist.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
 export interface BaseTimeServiceParams<TConfig extends EmptyObject = EmptyObject> extends BaseServiceParams<TConfig> {
-  chainArchivist: ReadArchivist
-  chainIterator: EventingChainBlockNumberIteratorService
+  blockViewer: BlockViewer
   ethProvider?: Provider
 }
 
@@ -20,12 +18,8 @@ export interface BaseTimeServiceParams<TConfig extends EmptyObject = EmptyObject
 export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> implements TimeSyncViewer {
   protected timeSyncViewer!: TimeSyncViewer
 
-  protected get chainArchivist() {
-    return this.params.chainArchivist
-  }
-
-  protected get chainIterator() {
-    return this.params.chainIterator
+  protected get blockViewer() {
+    return this.params.blockViewer
   }
 
   protected get ethProvider() {
@@ -38,11 +32,7 @@ export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> impl
 
   override async createHandler(): Promise<void> {
     await super.createHandler()
-    const blockViewer = blockViewerFromChainIteratorAndArchivist(
-      this.chainIterator,
-      this.chainArchivist,
-    )
-    this.timeSyncViewer = new SimpleTimeSyncViewer(blockViewer, this.ethProvider)
+    this.timeSyncViewer = new SimpleTimeSyncViewer(this.blockViewer, this.ethProvider)
   }
 
   async currentTime(domain: TimeDomain): Promise<[string, number]> {

package/src/blockViewerFromChainIteratorAndArchivist.ts

@@ -44,6 +44,18 @@ export function blockViewerFromChainIteratorAndArchivist(
       }
       return results
     },
+    blocksByNumber: async function (number: XL1BlockNumber, limit = 10): Promise<SignedHydratedBlockWithHashMeta[]> {
+      const results: SignedHydratedBlockWithHashMeta[] = []
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByNumber(number)
+        if (block) {
+          results.push(block)
+        } else {
+          break
+        }
+      }
+      return results
+    },
     currentBlock: async function (): Promise<SignedHydratedBlockWithHashMeta> {
       const head = await chainIterator.head()
       return this.blockByHash(head._hash) as Promise<SignedHydratedBlockWithHashMeta>