@xyo-network/chain-services 1.16.26 → 1.17.1

package/src/ChainService/Evm/Evm.ts

@@ -1,9 +1,12 @@
-import type { Address } from '@xylabs/sdk-js'
+import type {
+  Address, Hex, Promisable,
+} from '@xylabs/sdk-js'
 import {
   assertEx, toAddress, toEthAddress,
 } from '@xylabs/sdk-js'
 import type { StakedXyoChain } from '@xyo-network/typechain'
 import { StakedXyoChain__factory as StakedXyoChainFactory } from '@xyo-network/typechain'
+import type { AttoXL1, XL1BlockNumber } from '@xyo-network/xl1-protocol'
 import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
 import { getAddress } from 'ethers/address'
 import type { ContractRunner } from 'ethers/providers'
@@ -13,7 +16,7 @@ import type { BaseServiceParams } from '../../model/index.ts'
 
 export interface EvmChainServiceParams extends BaseServiceParams {
   contract: StakedXyoChain
-  id: Address
+  id: Hex
   runner: ContractRunner
 }
 
@@ -21,91 +24,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
   }
 
+  rewardForBlock(_block: XL1BlockNumber): Promisable<AttoXL1> {
+    throw new Error('Method not implemented.')
+  }
+
   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,27 +1,26 @@
-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'
+import type { AttoXL1, XL1BlockNumber } from '@xyo-network/xl1-protocol'
 import type { ChainService, Config } from '@xyo-network/xl1-protocol-sdk'
 
 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 +37,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)
@@ -71,6 +74,10 @@ export class MemoryChainService extends BaseService<MemoryChainServiceParams> im
     return await Promise.resolve(true)
   }
 
+  rewardForBlock(_block: XL1BlockNumber): Promisable<AttoXL1> {
+    throw new Error('Method not implemented.')
+  }
+
   async rewardsContract(): Promise<string> {
     return await Promise.resolve('')
   }

package/src/ChainValidator/XyoValidator.ts

@@ -2,61 +2,56 @@ import {
   assertEx, creatable, EmptyObject,
   Promisable,
 } from '@xylabs/sdk-js'
-import { AccountInstance } from '@xyo-network/account-model'
-import { ArchivistInstance, ReadArchivist } from '@xyo-network/archivist-model'
 import {
   BlockBoundWitness,
-  ChainId,
   SignedHydratedTransactionWithStorageMeta,
 } from '@xyo-network/xl1-protocol'
-import {
-  BlockRewardService, ElectionService, HydratedBlockStateValidationFunction, StakeIntentService,
-} from '@xyo-network/xl1-protocol-sdk'
+import { BlockViewer, HydratedBlockStateValidationFunction } from '@xyo-network/xl1-protocol-sdk'
 
 import { BaseService } from '../BaseService.ts'
 import { BaseServiceParams } from '../model/index.ts'
 import { Validator } from './model/index.ts'
 
 export interface XyoValidatorParams<TConfig extends EmptyObject = EmptyObject> extends BaseServiceParams<TConfig> {
-  account: AccountInstance
-  chainArchivist: ReadArchivist
-  chainId: ChainId
-  electionService: ElectionService
-  pendingBundledTransactionsArchivist: ArchivistInstance
-  rewardService: BlockRewardService
-  stakeIntentService: StakeIntentService
+  // account: AccountInstance
+  // blockRewardService: BlockRewardService
+  blockViewer: BlockViewer
+  // chainId: ChainId
+  // electionService: ElectionService
+  // pendingBundledTransactionsArchivist: ArchivistInstance
+  // stakeIntentService: StakeIntentService
   validateHydratedBlockState: HydratedBlockStateValidationFunction
 }
 
 @creatable()
 export class XyoValidator<TParams extends XyoValidatorParams = XyoValidatorParams> extends BaseService<TParams> implements Validator {
-  get address() {
-    return this.account.address
-  }
+  // get address() {
+  //   return this.account.address
+  // }
 
-  protected get account() {
-    return assertEx(this.params.account, () => 'account is required')
-  }
+  // protected get account() {
+  //   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() {
-    return assertEx(this.params.chainId, () => 'chainInfo is required')
-  }
+  // protected get chainInfo() {
+  //   return assertEx(this.params.chainId, () => 'chainInfo is required')
+  // }
 
-  protected get electionService() {
-    return assertEx(this.params.electionService, () => 'electionService is required')
-  }
+  // protected get electionService() {
+  //   return assertEx(this.params.electionService, () => 'electionService is required')
+  // }
 
-  protected get pendingBundledTransactionsArchivist() {
-    return assertEx(this.params.pendingBundledTransactionsArchivist, () => 'pendingBundledTransactions is required')
-  }
+  // protected get pendingBundledTransactionsArchivist() {
+  //   return assertEx(this.params.pendingBundledTransactionsArchivist, () => 'pendingBundledTransactions is required')
+  // }
 
-  protected get rewardService() {
-    return assertEx(this.params.rewardService, () => 'rewardService is required')
-  }
+  // protected get blockRewardService() {
+  //   return assertEx(this.params.blockRewardService, () => 'blockRewardService is required')
+  // }
 
   validatePendingBlock(_block: BlockBoundWitness): Promisable<Error[]> {
     return [] // await validateBlockProtocol(block, this.chainInfo)
@@ -66,7 +61,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/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -21,74 +21,74 @@ export interface BaseNetworkStakeStepRewardServiceParams extends BaseServicePara
 @creatable()
 export class BaseNetworkStakeStepRewardService extends BaseService<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
   networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardAddressHistory] not implemented.')
   }
 
   networkStakeStepRewardAddressReward(_context: StepIdentity, _address: Address): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardAddressReward] not implemented.')
   }
 
   networkStakeStepRewardAddressShare(_context: StepIdentity, _address: Address): Promisable<[bigint, bigint]> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardAddressShare] not implemented.')
   }
 
   networkStakeStepRewardClaimedByAddress(_address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardClaimedByAddress] not implemented.')
   }
 
   networkStakeStepRewardForPosition(_position: number, _range: [number, number]): Promisable<[bigint, bigint]> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardForPosition] not implemented.')
   }
 
   networkStakeStepRewardForStep(_context: StepIdentity): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardForStep] not implemented.')
   }
 
   networkStakeStepRewardForStepForPosition(_context: StepIdentity, _position: number): Promisable<[bigint, bigint]> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardForStepForPosition] not implemented.')
   }
 
   networkStakeStepRewardPoolRewards(_context: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPoolRewards] not implemented.')
   }
 
   networkStakeStepRewardPoolShares(_context: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPoolShares] not implemented.')
   }
 
   networkStakeStepRewardPositionWeight(_context: StepIdentity, _position: number): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPositionWeight] not implemented.')
   }
 
   networkStakeStepRewardPotentialPositionLoss(_context: StepIdentity, _position: number): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardPotentialPositionLoss] not implemented.')
   }
 
   networkStakeStepRewardRandomizer(_context: StepIdentity): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardRandomizer] not implemented.')
   }
 
   networkStakeStepRewardStakerCount(_context: StepIdentity): Promisable<number> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardStakerCount] not implemented.')
   }
 
   networkStakeStepRewardUnclaimedByAddress(_address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardUnclaimedByAddress] not implemented.')
   }
 
   networkStakeStepRewardWeightForAddress(_context: StepIdentity, _address: Address): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardWeightForAddress] not implemented.')
   }
 
   networkStakeStepRewardsForPosition(_position: number, _range: [number, number]): Promisable<Record<StepIdentityString, [bigint, bigint]>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardsForPosition] not implemented.')
   }
 
   networkStakeStepRewardsForRange(_range: [number, number]): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardsForRange] not implemented.')
   }
 
   networkStakeStepRewardsForStepLevel(_stepLevel: number, _range: [number, number]): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [networkStakeStepRewardsForStepLevel] not implemented.')
   }
 }

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -7,17 +7,19 @@ 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'
 import {
   asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, ChainId, HydratedTransactionValidationFunction, isTransactionBoundWitnessWithStorageMeta,
+  SignedHydratedBlockWithHashMeta,
   SignedHydratedTransactionWithHashMeta,
   SignedHydratedTransactionWithStorageMeta,
   XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
-import { PendingTransactionsService } from '@xyo-network/xl1-protocol-sdk'
+import {
+  findMostRecentBlock, MempoolViewer, PendingBlocksOptions, PendingTransactionsOptions,
+} from '@xyo-network/xl1-protocol-sdk'
 import { TransactionJsonSchemaValidator, validateTransaction } from '@xyo-network/xl1-validation'
 import { Mutex } from 'async-mutex'
 
@@ -28,14 +30,14 @@ import { hydratedTransactionToPayloadBundle } from './hydratedTransactionToPaylo
 
 export interface BasePendingTransactionsServiceParams extends BaseServiceParams {
   additionalPendingTransactionValidators?: HydratedTransactionValidationFunction[]
-  chainArchivist?: ArchivistInstance
-  chainId?: ChainId
-  pendingBundledTransactionsArchivist?: ArchivistInstance
-  rejectedTransactionsArchivist?: ArchivistInstance
+  chainArchivist: ArchivistInstance
+  chainId: ChainId
+  pendingBundledTransactionsArchivist: ArchivistInstance
+  rejectedTransactionsArchivist: ArchivistInstance
 }
 
 @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 +144,16 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
     })
   }
 
-  async getPendingTransactions(head: Hash, limit: number): Promise<SignedHydratedTransactionWithStorageMeta[]> {
+  pendingBlocks(_options?: PendingBlocksOptions): Promise<SignedHydratedBlockWithHashMeta[]> {
+    throw new Error('Method [pendingBlocks] not implemented.')
+  }
+
+  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/Schemas/BaseSchemasService.ts

@@ -22,7 +22,7 @@ export class BaseSchemasService extends BaseService<BaseSchemasServiceParams> im
 
   async schemas(head: Hash, schemas: Schema[]): Promise<Partial<Record<Schema, number>>> {
     return await spanRootAsync('transfers', async () => {
-      const summary = await schemasSummary(this.params.context)
+      const [summary] = await schemasSummary(this.params.context)
       const result: Record<Schema, number> = {}
       for (const schema of schemas) {
         const count = summary[schema] ?? 0

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,10 +34,10 @@ import { BaseService } from '../BaseService.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
 export interface XyoStakeIntentServiceParams extends BaseServiceParams<Pick<Config, 'producer'>> {
-  chainArchivist?: ArchivistInstance
-  chainIterator?: EventingChainBlockNumberIteratorService
-  chainStakeViewer?: ChainStakeViewer
-  stakeIntentStateArchivist?: ArchivistInstance
+  blockViewer: BlockViewer
+  chainArchivist: ArchivistInstance
+  chainStakeViewer: ChainStakeViewer
+  stakeIntentStateArchivist: ArchivistInstance
 }
 
 /**
@@ -65,30 +65,36 @@ 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 this.params.blockViewer
   }
 
-  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() {
-    return assertEx(this.params.chainStakeViewer, () => 'chainStakeViewer not set')
+    return assertEx(this.params.chainStakeViewer!, () => 'chainStakeViewer not set')
   }
 
   protected get stakeIntentStateArchivist() {
-    return assertEx(this.params.stakeIntentStateArchivist, () => 'stakeIntentStateArchivist not set')
+    return assertEx(this.params.stakeIntentStateArchivist!, () => 'stakeIntentStateArchivist not set')
+  }
+
+  static override async paramsHandler(params?: Partial<XyoStakeIntentServiceParams>): Promise<XyoStakeIntentServiceParams> {
+    return {
+      ...await super.paramsHandler(params),
+      blockViewer: assertEx(params?.blockViewer, () => 'blockViewer is required'),
+      chainArchivist: assertEx(params?.chainArchivist, () => 'chainArchivist is required'),
+      chainStakeViewer: assertEx(params?.chainStakeViewer, () => 'chainStakeViewer is required'),
+      stakeIntentStateArchivist: assertEx(params?.stakeIntentStateArchivist, () => 'stakeIntentStateArchivist is required'),
+    } as XyoStakeIntentServiceParams
   }
 
   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 +214,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/StepStake/BaseStepStakeService.ts

@@ -15,10 +15,10 @@ export interface BaseStepStakeServiceParams extends BaseServiceParams {
 @creatable()
 export class BaseStepStakeService extends BaseService<BaseStepStakeServiceParams> implements StepStakeViewer {
   stepStake(_step: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [stepStake] not implemented.')
   }
 
   stepStakeForAddress(_address: Address, _step: StepIdentity): Promisable<bigint> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [stepStakeForAddress] not implemented.')
   }
 }

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]> {