@xyo-network/xl1-protocol-sdk 1.16.26 → 1.17.1

package/src/payloads/index.ts

@@ -2,4 +2,3 @@ export * from './AddressPairPayload.ts'
 export * from './netBalancesForPayloads.ts'
 export * from './netSchemasForPayloads.ts'
 export * from './netTransfersForPayloads.ts'
-export * from './summary/index.ts'

package/src/primitives/index.ts

@@ -1,5 +1,6 @@
 export * from './readPayloadMapFromStore.ts'
+export * from './rewardFromBlockNumber.ts'
+export * from './state/index.ts'
 export * from './step/index.ts'
-export * from './summary/index.ts'
 export * from './timeBudget.ts'
 export * from './transaction/index.ts'

package/src/primitives/rewardFromBlockNumber.ts

@@ -0,0 +1,25 @@
+import { toFixedPoint } from '@xylabs/sdk-js'
+import { asAttoXL1, type XL1BlockNumber } from '@xyo-network/xl1-protocol'
+
+export const rewardFromBlockNumber = (places = 18) => {
+  return (
+    blockNumber: XL1BlockNumber,
+    startingReward = asAttoXL1(toFixedPoint(30_000n, places)),
+    blocksPerStep = 1_000_000,
+    stepFactorNumerator = 90n,
+    stepFactorDenominator = 100n,
+    minBlockReward = asAttoXL1(toFixedPoint(30n, places)),
+    creatorReward = asAttoXL1(toFixedPoint(20_000_000_000n, places)),
+  ) => {
+    if (blockNumber === 0) {
+      return creatorReward
+    }
+    const step = Math.floor((blockNumber + blocksPerStep) / blocksPerStep)
+    const stepExp = BigInt(step - 1)
+    const poweredNumerator = stepExp > 0 ? stepFactorNumerator ** stepExp : 1n
+    const poweredDenominator = stepExp > 0 ? stepFactorDenominator ** stepExp : 1n
+    let reward = (startingReward * poweredNumerator) / poweredDenominator
+    // eslint-disable-next-line unicorn/prefer-math-min-max
+    return asAttoXL1((reward < minBlockReward) ? minBlockReward : reward)
+  }
+}

package/src/primitives/state/findMostRecentBlock.ts

@@ -0,0 +1,44 @@
+import type { NextOptions, ReadArchivist } from '@xyo-network/archivist-model'
+import type {
+  Payload, Sequence, WithStorageMeta,
+} from '@xyo-network/payload-model'
+import type { SignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
+import { isSignedBlockBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+
+// TODO: Use some smart value relative to DEFAULT_BLOCK_SIZE
+// to ensure we're likely to find it in a single request
+// without bringing back too much data
+const DEFAULT_NEXT_OPTIONS: NextOptions = { limit: 50 }
+
+/**
+ * Iterates an archivist to find the most recent block
+ * @param chainArchivist The archivist to iterate over for the most recent chain block
+ * @param nextOptions The options to use when iterating the archivist
+ * @param maxIterations The max number of iterations to perform when finding the most recent block
+ * @returns The most recent block found in the archivist or undefined if no blocks are found
+ */
+export const findMostRecentBlock = async (
+  chainArchivist: ReadArchivist,
+  nextOptions: NextOptions = DEFAULT_NEXT_OPTIONS,
+  maxIterations = Number.POSITIVE_INFINITY,
+): Promise<SignedBlockBoundWitnessWithHashMeta | undefined> => {
+  let mostRecentBlock: SignedBlockBoundWitnessWithHashMeta | undefined
+  let cursor: Sequence | undefined
+  let batch: WithStorageMeta<Payload>[]
+  let iterations = 0
+  do {
+    batch = await chainArchivist.next({
+      ...nextOptions, order: 'desc', cursor,
+    })
+    const blocks = batch.filter(isSignedBlockBoundWitnessWithStorageMeta)
+    const last = blocks?.at(0)
+    if (last) {
+      mostRecentBlock = last
+      break
+    } else {
+      cursor = batch.at(-1)?._sequence
+    }
+    iterations = iterations + 1
+  } while (batch.length > 0 && iterations < maxIterations)
+  return mostRecentBlock
+}

package/src/primitives/state/hydratedBlockByNumber.ts

@@ -0,0 +1,19 @@
+import { assertEx } from '@xylabs/sdk-js'
+import type { HydratedBlockWithHashMeta, XL1BlockNumber } from '@xyo-network/xl1-protocol'
+
+import { blockFromBlockNumber, hydrateBlock } from '../../block/index.ts'
+import { type ChainContextRead, withContextCacheResponse } from '../../model/index.ts'
+
+export async function hydratedBlockByNumber(context: ChainContextRead, blockNumber: XL1BlockNumber): Promise<HydratedBlockWithHashMeta | null> {
+  if (blockNumber < 0) throw new Error(`Block number ${blockNumber} is less than 0`)
+  if (blockNumber > Number.MAX_SAFE_INTEGER) throw new Error(`Block number ${blockNumber} is greater than the maximum safe integer`)
+  if (blockNumber % 1 !== 0) throw new Error(`Block number ${blockNumber} is not an integer`)
+  const cacheKey = `${blockNumber}`
+  return await withContextCacheResponse(context, 'hydratedBlockByNumber', cacheKey, async () => {
+    const block = assertEx(
+      await blockFromBlockNumber(context, blockNumber),
+      () => `Could not find block for block number ${blockNumber}`,
+    )
+    return await hydrateBlock(context.store, block._hash)
+  })
+}

package/src/primitives/state/index.ts

@@ -0,0 +1,2 @@
+export * from './findMostRecentBlock.ts'
+export * from './hydratedBlockByNumber.ts'

package/src/provider/XyoRunner.ts

@@ -1,6 +1,12 @@
 import type { Hash, Promisable } from '@xylabs/sdk-js'
 import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 
-export interface XyoRunner {
+import type { MempoolRunner } from '../runners/index.ts'
+
+export interface XyoRunnerMethods {
   broadcastTransaction(transaction: SignedHydratedTransaction): Promisable<Hash>
 }
+
+export interface XyoRunner extends XyoRunnerMethods {
+  mempool?: MempoolRunner
+}

package/src/provider/viewer/XyoViewer.ts

@@ -1,26 +1,37 @@
 import type {
+  Address, Hash, Promisable,
+} from '@xylabs/sdk-js'
+import type { AttoXL1, XL1BlockRange } from '@xyo-network/xl1-protocol'
+
+import type {
+  AccountBalanceHistoryItem,
   AccountBalanceViewer,
-  AccountBalanceViewerMethods,
-  BlockViewierMethods,
+  BlockViewer,
+  BlockViewerMethods,
   ChainViewerMethods,
   ForkViewerMethods,
+  MempoolViewer,
   NetworkStakeStepRewardViewer,
   StakeViewerMethods,
+  StepViewer,
   TransactionViewerMethods,
   TransferBalanceViewerMethods,
 } from '../../viewers/index.ts'
 import type { NetworkStakeViewer } from './NetworkStake/index.ts'
-import type { StepViewer } from './StepViewer.ts'
 
-export interface XyoViewerMethods extends AccountBalanceViewerMethods, TransferBalanceViewerMethods,
-  NetworkStakeStepRewardViewer, AccountBalanceViewer,
-  ChainViewerMethods, BlockViewierMethods, TransactionViewerMethods, StakeViewerMethods, ForkViewerMethods {
+export interface XyoViewerMethods extends
+  TransferBalanceViewerMethods, NetworkStakeStepRewardViewer,
+  Pick<ChainViewerMethods, 'chainId'>, BlockViewerMethods, TransactionViewerMethods, StakeViewerMethods, ForkViewerMethods {
+  accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AttoXL1>
+  accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AccountBalanceHistoryItem[]>
 }
 
-export interface XyoViewer extends XyoViewerMethods {
+export interface XyoViewer extends BlockViewer, XyoViewerMethods {
   account?: {
     balance?: AccountBalanceViewer
   }
+  block?: BlockViewer
+  mempool?: MempoolViewer
   networkStake?: NetworkStakeViewer
   step?: StepViewer
 }

package/src/provider/viewer/index.ts

@@ -1,3 +1,2 @@
 export * from './NetworkStake/index.ts'
-export * from './StepViewer.ts'
 export * from './XyoViewer.ts'

package/src/runners/Block.ts

@@ -0,0 +1,10 @@
+import type { SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+export interface BlockRunnerMethods {
+  produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force: true): Promise<SignedHydratedBlockWithHashMeta>
+  produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: false): Promise<SignedHydratedBlockWithHashMeta | undefined>
+}
+
+export interface BlockRunner extends BlockRunnerMethods {
+
+}

package/src/runners/Mempool.ts

@@ -0,0 +1,9 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type { SignedHydratedBlock, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+
+export interface MempoolRunnerMethods {
+  submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]>
+  submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]>
+}
+
+export interface MempoolRunner extends MempoolRunnerMethods {}

package/src/runners/index.ts

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

package/src/services/BlockProducerService.ts

@@ -1,8 +1,9 @@
 import type {
   Addressable,
-  BlockBoundWitness, HydratedBlockWithHashMeta, IterableRepository,
+  BlockBoundWitness, IterableRepository,
+  SignedHydratedBlockWithHashMeta,
 } from '@xyo-network/xl1-protocol'
 
-export type NextBlockProducer = IterableRepository<BlockBoundWitness, HydratedBlockWithHashMeta | undefined>
+export type NextBlockProducer = IterableRepository<BlockBoundWitness, SignedHydratedBlockWithHashMeta | undefined>
 
 export interface BlockProducerService extends Addressable, NextBlockProducer {}

package/src/services/Chain/BaseChainService.ts

@@ -1,5 +1,3 @@
-import type { ChainId } from '@xyo-network/xl1-protocol'
-
 export interface BaseChainService {
-  chainId: ChainId
+
 }

package/src/services/Chain/ChainService.ts

@@ -1,5 +1,6 @@
-import type { ChainContractViewer } from '../../viewers/index.ts'
+import type {
+  ChainContractViewer, ChainStakeViewer, ChainViewer,
+} from '../../viewers/index.ts'
 import type { BaseChainService } from './BaseChainService.ts'
-import type { ChainStaker, ChainStakeViewer } from './interfaces/index.ts'
 
-export interface ChainService extends ChainContractViewer, ChainStakeViewer, ChainStaker, BaseChainService {}
+export interface ChainService extends ChainContractViewer, ChainStakeViewer, ChainViewer, BaseChainService {}

package/src/services/Chain/index.ts

@@ -1,4 +1,3 @@
 export * from './BaseChainService.ts'
 export * from './ChainHeadService.ts'
 export * from './ChainService.ts'
-export * from './interfaces/index.ts'

package/src/services/index.ts

@@ -1,7 +1,5 @@
 export * from './AccountTransfersService.ts'
 export * from './BlockProducerService.ts'
-export * from './BlockRewardService.ts'
-export * from './BlockRewardServiceV2.ts'
 export * from './Chain/index.ts'
 export * from './ChainIterator/index.ts'
 export * from './Election.ts'

package/src/simple/accountBalance/SimpleAccountBalanceViewer.ts

@@ -3,6 +3,7 @@ import type {
 } from '@xylabs/sdk-js'
 import {
   AbstractCreatable,
+  asHash,
   assertEx, exists, isDefined,
 } from '@xylabs/sdk-js'
 import { spanRootAsync } from '@xylabs/telemetry'
@@ -17,9 +18,15 @@ import {
 } from '@xyo-network/xl1-protocol'
 
 import { deepCalculateFramesFromRange } from '../../block/index.ts'
-import type { BalanceStepSummaryContext, TransfersStepSummaryContext } from '../../model/index.ts'
-import type { TransfersStepSummary } from '../../payloads/index.ts'
-import { balancesSummary, transfersStepSummaryFromRange } from '../../primitives/index.ts'
+import type { Qualified } from '../../model/index.ts'
+import type {
+  BalanceStepSummaryContext, TransfersStepSummary,
+  TransfersStepSummaryContext,
+} from '../../summary/index.ts'
+import {
+  balancesSummary,
+  transfersStepSummaryFromRange,
+} from '../../summary/index.ts'
 import type {
   AccountBalanceHistoryItem, AccountBalanceViewer, BlockViewer,
 } from '../../viewers/index.ts'
@@ -27,7 +34,7 @@ import type {
 export interface SimpleAccountBalanceViewerParams extends CreatableParams {
   blockViewer: BlockViewer
   context: BalanceStepSummaryContext
-  transferContext: TransfersStepSummaryContext
+  transfersSummaryContext: TransfersStepSummaryContext
 }
 
 export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountBalanceViewerParams> implements AccountBalanceViewer {
@@ -39,23 +46,27 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
     return this.params.context!
   }
 
-  get transferContext(): TransfersStepSummaryContext {
-    return this.params.transferContext!
+  get transfersSummaryContext(): TransfersStepSummaryContext {
+    return this.params.transfersSummaryContext!
   }
 
   static override async paramsHandler(params: Partial<SimpleAccountBalanceViewerParams>) {
     assertEx(params.blockViewer, () => 'blockViewer is required')
     assertEx(params.context, () => 'context is required')
-    assertEx(params.transferContext, () => 'transferContext is required')
+    assertEx(params.transfersSummaryContext, () => 'transfersSummaryContext is required')
 
     return { ...await super.paramsHandler(params) }
   }
 
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountsBalances([address], headOrRange)
+    const balances = await this.accountBalances([address], headOrRange)
     return balances[address] ?? AttoXL1(0n)
   }
 
+  accountBalanceHistories(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Record<Address, AccountBalanceHistoryItem[]>> {
+    throw new Error('Method [accountBalanceHistories] not implemented.')
+  }
+
   async accountBalanceHistory(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AccountBalanceHistoryItem[]> {
     const range = asRange(headOrRange)
     const startingRange = asXL1BlockRange(range ?? [0, await this.blockViewer.currentBlockNumber()], true)
@@ -84,24 +95,64 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
     return result
   }
 
-  async accountsBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
-    return await spanRootAsync('balances', async () => {
-      const summary = await balancesSummary(
+  async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Record<Address, AttoXL1>> {
+    const [result] = (await this.qualifiedAccountBalances(address, _headOrRange))
+    return result
+  }
+
+  async qualifiedAccountBalanceHistories(
+    addresses: Address[],
+    headOrRange?: Hash | XL1BlockRange,
+  ): Promise<Qualified<Record<Address, AccountBalanceHistoryItem[]>>> {
+    const head = asHash(headOrRange) ?? await this.blockViewer.currentBlockHash()
+    const range = asXL1BlockRange(headOrRange) ?? asXL1BlockRange([0,
+      assertEx(
+        await this.blockViewer.blockByHash(head),
+        () => `Error: Could not find block with hash ${head}`,
+      )[0].block])
+    const qualifiedEntries: [Address, Qualified<AccountBalanceHistoryItem[]>][] = await Promise.all(addresses.map(async address => ([
+      address,
+      await this.qualifiedAccountBalanceHistory(address, range),
+    ])))
+
+    const entries = qualifiedEntries.map(([address, [history]]) => {
+      return [address, history]
+    })
+    const qualifiedRange = qualifiedEntries[0][1][1]
+    const qualifiedHeadHash = qualifiedEntries[0][1][2]
+
+    // check for drift
+    for (const [_, [__, range, headHash]] of qualifiedEntries) {
+      assertEx(
+        range[0] === qualifiedRange[0] && range[1] === qualifiedRange[1],
+        () => 'Inconsistent ranges in qualifiedAccountBalanceHistories',
+      )
+      assertEx(
+        headHash === qualifiedHeadHash,
+        () => 'Inconsistent head hashes in qualifiedAccountBalanceHistories',
+      )
+    }
+
+    return [Object.fromEntries(entries), qualifiedRange, qualifiedHeadHash]
+  }
+
+  async qualifiedAccountBalances(
+    address: Address[],
+    _headOrRange?: Hash | XL1BlockRange,
+  ): Promise<Qualified<Record<Address, AttoXL1>>> {
+    return await spanRootAsync('qualifiedAccountsBalances', async () => {
+      const qualifiedSummary = await balancesSummary(
         this.context,
       )
       const result: Record<Address, AttoXL1> = {}
       for (const addr of address) {
-        const summaryBalance = summary[addr] ?? 0n
+        const summaryBalance = qualifiedSummary[0][addr] ?? 0n
         result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
       }
-      return result
+      return [result, qualifiedSummary[1], qualifiedSummary[2]]
     })
   }
 
-  accountsBalancesHistory(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
-    throw new Error('Method not implemented.')
-  }
-
   private async distillTransferHistory(address: Address, range: XL1BlockRange, max: number = 50): Promise<XL1BlockNumber[]> {
     if ((range[1] - range[0]) <= StepSizes[0] || max <= 1) {
       return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[1] - i).slice(0, max).map(n => asXL1BlockNumber(n, true))
@@ -109,7 +160,7 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
     const frames = deepCalculateFramesFromRange(asXL1BlockRange(range, true))
     const transferSummaryPairs = await Promise.all(frames.map(
       async (frame) => {
-        return [frame, await transfersStepSummaryFromRange(this.transferContext, frame)]
+        return [frame, await transfersStepSummaryFromRange(this.transfersSummaryContext, frame)]
       },
     )) as [XL1BlockRange, WithStorageMeta<TransfersStepSummary>][]
 
@@ -139,4 +190,39 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
     }
     return [...resultBlockNumbers].toSorted((a, b) => b - a).slice(0, max)
   }
+
+  private async qualifiedAccountBalanceHistory(
+    address: Address,
+    headOrRange?: Hash | XL1BlockRange,
+  ): Promise<Qualified<AccountBalanceHistoryItem[]>> {
+    const range = asRange(headOrRange)
+    const headHash = asHash(headOrRange)
+    const [head] = assertEx(isDefined(headHash)
+      ? (await this.blockViewer.blockByHash(headHash))
+      : (await this.blockViewer.currentBlock()), () => 'Could not resolve head block')
+    const startingRange = asXL1BlockRange(range ?? [0, head.block], true)
+    const blockNumbers = await this.distillTransferHistory(address, startingRange)
+    const blocks = (await Promise.all(blockNumbers.map(async bn => await this.blockViewer.blockByNumber(bn)))).filter(exists)
+    const result: AccountBalanceHistoryItem[] = []
+    for (const block of blocks) {
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : undefined).filter(exists)
+      const transfers = transferIndexes.map((index) => {
+        const hash = block[0].payload_hashes[index]
+        return assertEx(
+          block[1].find(p => p._hash === hash) as WithStorageMeta<Transfer>,
+          () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`,
+        )
+      }).filter(exists).filter(t => ((t.from === address) || (isDefined(t.transfers[address]))))
+      if (transfers.length === 0) {
+        continue
+      }
+      const pairs: [SignedBlockBoundWitnessWithHashMeta, WithHashMeta<Transfer>][] = (transfers.map((transfer) => {
+        return [block[0], transfer]
+      }))
+      result.push(...pairs.map(([block, transfer]) => [block,
+        null,
+        transfer] satisfies AccountBalanceHistoryItem))
+    }
+    return [result, startingRange, head._hash]
+  }
 }

package/src/simple/block/SimpleBlockViewer.ts

@@ -0,0 +1,172 @@
+import type { CreatableParams, Hash } from '@xylabs/sdk-js'
+import {
+  AbstractCreatable,
+  assertEx,
+  exists,
+  isDefined,
+  spanRootAsync,
+} from '@xylabs/sdk-js'
+import type { ReadArchivist } from '@xyo-network/archivist-model'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
+import {
+  asSignedHydratedBlockWithHashMeta,
+  asXL1BlockNumber,
+  type SignedHydratedBlockWithHashMeta,
+  type XL1BlockNumber,
+} from '@xyo-network/xl1-protocol'
+
+import { hydrateBlock } from '../../block/index.ts'
+import { LruCacheMap } from '../../driver/index.ts'
+import type {
+  ChainContextRead,
+  ChainStoreRead, PayloadMap,
+} from '../../model/index.ts'
+import { findMostRecentBlock, hydratedBlockByNumber } from '../../primitives/index.ts'
+import { HydratedCache } from '../../utils/index.ts'
+import type { BlockViewer } from '../../viewers/index.ts'
+
+export interface SimpleBlockViewerParams extends CreatableParams {
+  context: ChainContextRead
+  finalizedArchivist?: ReadArchivist
+}
+
+export class SimpleBlockViewer extends AbstractCreatable<SimpleBlockViewerParams> implements BlockViewer {
+  private _payloadCache: PayloadMap<WithHashMeta<Payload>> | undefined
+  private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithHashMeta> | undefined
+
+  get context(): ChainContextRead {
+    return this.params.context!
+  }
+
+  get finalizedArchivist(): ReadArchivist {
+    return this.params.finalizedArchivist!
+  }
+
+  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithHashMeta> {
+    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
+    const chainMap = this.context.store.chainMap
+    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithHashMeta>(chainMap, async (
+      { chainMap }: ChainStoreRead,
+      hash: Hash,
+      maxDepth?: number,
+      minDepth?: number,
+    ) => {
+      const result = await hydrateBlock({ chainMap }, hash, maxDepth, minDepth)
+      return asSignedHydratedBlockWithHashMeta(result, true)
+    }, 200)
+    return this._signedHydratedBlockCache
+  }
+
+  protected get payloadCache(): PayloadMap<WithHashMeta<Payload>> {
+    if (this._payloadCache) return this._payloadCache
+    this._payloadCache = new LruCacheMap<Hash, WithHashMeta<Payload>>({ max: 10_000 })
+    return this._payloadCache
+  }
+
+  static override async paramsHandler(params: Partial<SimpleBlockViewerParams>) {
+    assertEx(params.context, () => 'context is required')
+    assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required')
+
+    return { ...await super.paramsHandler(params) }
+  }
+
+  async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
+    return await spanRootAsync('blockByHash', async () => {
+      const cache = this.hydratedBlockCache
+      return await cache.get(hash)
+    }, this.tracer)
+  }
+
+  async blockByNumber(blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
+    return await spanRootAsync('blockByNumber', async () => {
+      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(this.context, blockNumber)) ?? null
+    }, this.tracer)
+  }
+
+  async blocksByHash(hash: Hash, limit = 50): Promise<SignedHydratedBlockWithHashMeta[]> {
+    return await spanRootAsync('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.tracer)
+  }
+
+  async blocksByNumber(blockNumber: XL1BlockNumber, limit = 50): Promise<SignedHydratedBlockWithHashMeta[]> {
+    return await spanRootAsync('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.blockByNumber(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.blockByNumber(previousNumber)
+      }
+      return blocks.map(b => asSignedHydratedBlockWithHashMeta(b, true))
+    }, this.tracer)
+  }
+
+  async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
+    return await spanRootAsync('currentBlock', async () => {
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      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)
+  }
+
+  async currentBlockHash(): Promise<Hash> {
+    return await spanRootAsync('currentBlockHash', async () => {
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      return currentHead._hash
+    }, this.tracer)
+  }
+
+  async currentBlockNumber(): Promise<XL1BlockNumber> {
+    return await spanRootAsync('currentBlockNumber', async () => {
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      return asXL1BlockNumber(currentHead.block, { name: 'currentBlockNumber' })
+    }, this.tracer)
+  }
+
+  async payloadByHash(hash: Hash): Promise<WithHashMeta<Payload> | null> {
+    const cachedPayload = await this.payloadCache.get(hash)
+    if (cachedPayload) {
+      return cachedPayload
+    } else {
+      const [result] = await this.finalizedArchivist.get([hash])
+      if (isDefined(result)) {
+        await this.payloadCache.set(hash, result)
+      }
+      return result ?? null
+    }
+  }
+
+  async payloadsByHash(hashes: Hash[]): Promise<WithHashMeta<Payload>[]> {
+    let remainingHashes = [...hashes]
+    const cachedPayloads = await this.payloadCache.getMany(remainingHashes)
+    const cachedHashes = new Set(cachedPayloads.map(p => p._hash))
+    remainingHashes = remainingHashes.filter(h => !cachedHashes.has(h))
+    const remainingPayloads = remainingHashes.length > 0
+      ? await this.finalizedArchivist.get(remainingHashes)
+      : []
+    return [...cachedPayloads, ...remainingPayloads.filter(exists)]
+  }
+
+  protected async getCurrentHead() {
+    const chainArchivist = this.finalizedArchivist
+    return await findMostRecentBlock(chainArchivist)
+  }
+}

package/src/simple/block/index.ts

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

package/src/simple/blockReward/SimpleBlockRewardViewer.ts

@@ -0,0 +1,34 @@
+import {
+  AbstractCreatable,
+  creatable, CreatableParams, Promisable,
+} from '@xylabs/sdk-js'
+import { AttoXL1, XL1BlockNumber } from '@xyo-network/xl1-protocol'
+
+import { rewardFromBlockNumber } from '../../primitives/index.ts'
+import { BlockRewardViewer } from '../../viewers/index.ts'
+
+export interface SimpleBlockRewardViewerParams extends CreatableParams {
+  creatorReward: AttoXL1
+  initialReward: AttoXL1
+  minRewardPerBlock: AttoXL1
+  stepFactorDenominator: bigint
+  stepFactorNumerator: bigint
+  stepSize: XL1BlockNumber
+}
+
+@creatable()
+export class SimpleBlockRewardViewer extends AbstractCreatable<SimpleBlockRewardViewerParams> implements BlockRewardViewer {
+  protected rewardFromBlockNumber = rewardFromBlockNumber(18)
+
+  allowedRewardForBlock(block: XL1BlockNumber): Promisable<AttoXL1> {
+    return this.rewardFromBlockNumber(
+      block,
+      this.params.initialReward,
+      this.params.stepSize,
+      this.params.stepFactorNumerator,
+      this.params.stepFactorDenominator,
+      this.params.minRewardPerBlock,
+      this.params.creatorReward,
+    )
+  }
+}

package/src/simple/blockReward/index.ts

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