@xyo-network/xl1-protocol-sdk 1.17.7 → 1.18.0-rc.1

package/src/primitives/chain/time/externalBlockRangeFromXL1BlockRange.ts

@@ -0,0 +1,16 @@
+import type { BlockRange, XL1BlockRange } from '@xyo-network/xl1-protocol'
+
+import type { BaseContext } from '../../../model/index.ts'
+import type { BlockViewer } from '../../../viewers/index.ts'
+import { externalBlockNumberFromXL1BlockNumber } from './externalBlockNumberFromXL1BlockNumber.ts'
+
+export async function externalBlockRangeFromXL1BlockRange(
+  context: BaseContext,
+  blockViewer: BlockViewer,
+  xl1BlockRange: XL1BlockRange,
+  externalTimeName: 'ethereum' = 'ethereum',
+): Promise<BlockRange> {
+  const start = await externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockRange[0], externalTimeName)
+  const end = await externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockRange[1], externalTimeName)
+  return [start, end]
+}

package/src/primitives/chain/time/index.ts

@@ -0,0 +1,3 @@
+export * from './externalBlockNumberFromXL1BlockNumber.ts'
+export * from './externalBlockRangeFromStep.ts'
+export * from './externalBlockRangeFromXL1BlockRange.ts'

package/src/primitives/index.ts

@@ -1,5 +1,11 @@
+export * from './block/index.ts'
+export * from './chain/index.ts'
+export * from './mapToMapType.ts'
+export * from './payload/index.ts'
 export * from './readPayloadMapFromStore.ts'
 export * from './rewardFromBlockNumber.ts'
+export * from './rewards/index.ts'
+export * from './stake/index.ts'
 export * from './state/index.ts'
 export * from './step/index.ts'
 export * from './timeBudget.ts'

package/src/primitives/mapToMapType.ts

@@ -0,0 +1,35 @@
+import { isDefined } from '@xylabs/sdk-js'
+
+import type { SyncIterableMap } from '../map/index.ts'
+
+export function mapToMapType<K extends {}, V extends {}>(map: Map<K, V> | SyncIterableMap<K, V>): SyncIterableMap<K, V> {
+  return {
+    get: (key: K) => map.get(key),
+    has: (key: K) => map.has(key),
+    set: (key: K, value: V) => {
+      map.set(key, value)
+    },
+    setMany: (entries: [K, V][]) => {
+      for (const [key, value] of entries) {
+        map.set(key, value)
+      }
+    },
+    delete: (key: K) => map.delete(key),
+    clear: () => map.clear(),
+    getMany: (keys: K[]) => {
+      const result: V[] = []
+      for (const key of keys) {
+        const value = map.get(key)
+        if (isDefined(value)) {
+          result.push(value)
+        }
+      }
+      return result
+    },
+    [Symbol.iterator]: function* (): Iterator<[K, V]> {
+      for (const entry of map) {
+        yield entry
+      }
+    },
+  }
+}

package/src/primitives/payload/index.ts

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

package/src/primitives/payload/mergeTransfers.ts

@@ -0,0 +1,15 @@
+import type { Address } from '@xylabs/sdk-js'
+import { hexToBigInt, toAddress } from '@xylabs/sdk-js'
+import type { Transfer } from '@xyo-network/xl1-protocol'
+
+export function mergeTransfers(transfers: Transfer[]): Record<Address, Record<Address, bigint>> {
+  const result: Record<Address, Record<Address, bigint>> = {}
+  for (const transfer of transfers) {
+    result[transfer.from] = result[transfer.from] ?? {}
+    for (const [to, value] of Object.entries(transfer.transfers)) {
+      const typedTo = toAddress(to)
+      result[transfer.from][typedTo] = (result[transfer.from][typedTo] ?? 0n) + (hexToBigInt(value))
+    }
+  }
+  return result
+}

package/src/primitives/readPayloadMapFromStore.ts

@@ -1,24 +1,54 @@
 import type { Hash } from '@xylabs/sdk-js'
 import { isDefined } from '@xylabs/sdk-js'
-import type { ReadArchivist } from '@xyo-network/archivist-model'
-import type { Payload } from '@xyo-network/payload-model'
+import type { ReadArchivist, ReadWriteArchivist } from '@xyo-network/archivist-model'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
 
-import { isReadArchivist } from '../block/index.ts'
-import type { PayloadMapRead } from '../model/index.ts'
+import { isReadArchivist, isReadWriteArchivist } from '../block/index.ts'
+import type { PayloadMap, PayloadMapRead } from '../model/index.ts'
 
-export function readPayloadMapFromStore<T extends Payload>(store: ReadArchivist<T> | PayloadMapRead<T>): PayloadMapRead<T> {
+export function readPayloadMapFromStore<T extends Payload>(store: ReadArchivist<T> | PayloadMapRead<WithStorageMeta<T>>): PayloadMapRead<WithStorageMeta<T>> {
   if (isReadArchivist(store)) {
     return {
-      get: async (hash: Hash): Promise<T | undefined> => {
+      get: async (hash: Hash) => {
         return (await store.get([hash]))[0]
       },
-      getMany: async (hashes: Hash[]): Promise<T[]> => {
+      getMany: async (hashes: Hash[]) => {
         return (await store.get(hashes))
       },
-      has: async (hash: Hash): Promise<boolean> => {
+      has: async (hash: Hash) => {
         return isDefined((await store.get([hash]))[0])
       },
     }
   }
   return store
 }
+
+export function payloadMapFromStore<T extends Payload>(store: ReadWriteArchivist<T> | PayloadMap<WithStorageMeta<T>>): PayloadMap<WithStorageMeta<T>> {
+  if (isReadWriteArchivist(store)) {
+    return {
+      get: async (hash: Hash) => {
+        return (await store.get([hash]))[0]
+      },
+      getMany: async (hashes: Hash[]) => {
+        return (await store.get(hashes))
+      },
+      has: async (hash: Hash) => {
+        return isDefined((await store.get([hash]))[0])
+      },
+      clear: async () => {
+        return await store.clear()
+      },
+      delete: async (id: Hash) => {
+        await store.delete([id])
+        return true
+      },
+      set: async (_id: Hash, data: T) => {
+        await store.insert([data])
+      },
+      setMany: async (entries: [Hash, T][]) => {
+        await store.insert(entries.map(e => e[1]))
+      },
+    } satisfies PayloadMap<WithStorageMeta<T>>
+  }
+  return store
+}

package/src/primitives/rewards/index.ts

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

package/src/primitives/rewards/networkStakeStepRewardPositionWeight.ts

@@ -0,0 +1,21 @@
+import { type StepIdentity } from '@xyo-network/xl1-protocol'
+
+import type { StakedChainContextRead } from '../../model/index.ts'
+import type { BlockViewer } from '../../viewers/Block.ts'
+import { externalBlockRangeFromStep } from '../chain/time/index.ts'
+import { weightedStakeForRangeByPosition } from '../stake/index.ts'
+
+export async function networkStakeStepRewardPositionWeight(
+  context: StakedChainContextRead,
+  blockViewer: BlockViewer,
+  stepContext: StepIdentity,
+  position: number,
+): Promise<bigint> {
+  const result = await weightedStakeForRangeByPosition(
+    context,
+    blockViewer,
+    await externalBlockRangeFromStep(context, blockViewer, stepContext),
+    position,
+  )
+  return result
+}

package/src/primitives/stake/activeStakeAtTimeByAddress.ts

@@ -0,0 +1,26 @@
+import type { Address } from '@xylabs/sdk-js'
+import { isDefined } from '@xylabs/sdk-js'
+
+import type { StakeEventsViewer } from '../../viewers/index.ts'
+import { mergedAddRemoveStakeEventsByStaker } from './mergedAddRemoveStakeEventsByStaker.ts'
+
+export async function activeStakeAtTimeByAddress(
+  chain: StakeEventsViewer,
+  staked: Address,
+  time: number,
+  staker?: Address,
+): Promise<bigint> {
+  const stakeEvents = (await mergedAddRemoveStakeEventsByStaker(chain, [0, time], staked, staker)).toSorted((a, b) => a.time - b.time)
+  let result = 0n
+  for (const event of stakeEvents) {
+    if (event.time > time) break
+    if (event.args.staked !== staked) continue
+    if (isDefined(staker) && (event.args.staker !== staker)) continue
+    if (event.name === 'StakeAdded') {
+      result += event.args.amount
+    } else if (event.name === 'StakeRemoved') {
+      result -= event.args.amount
+    }
+  }
+  return result
+}

package/src/primitives/stake/activeStakeAtTimeByPosition.ts

@@ -0,0 +1,24 @@
+import { isUndefined } from '@xylabs/sdk-js'
+
+import type { StakeEventsViewer } from '../../viewers/index.ts'
+import { mergedAddRemoveStakeEventsByPosition } from './mergedAddRemoveStakeEventsByPosition.ts'
+
+export async function activeStakeAtTimeByPosition(
+  chainStakeEvents: StakeEventsViewer,
+  externalTime: number,
+  position?: number,
+): Promise<bigint> {
+  const stakeEvents = (await mergedAddRemoveStakeEventsByPosition(chainStakeEvents, [0, externalTime], position)).toSorted((a, b) => a.time - b.time)
+  let result = 0n
+  for (const event of stakeEvents) {
+    if (event.time > externalTime) break
+    if (isUndefined(position) || position === Number(event.args.id)) {
+      if (event.name === 'StakeAdded') {
+        result += event.args.amount
+      } else if (event.name === 'StakeRemoved') {
+        result -= event.args.amount
+      }
+    }
+  }
+  return result
+}

package/src/primitives/stake/allStakersForRange.ts

@@ -0,0 +1,31 @@
+import {
+  type Address,
+  toAddress,
+} from '@xylabs/sdk-js'
+
+import type { StakeEventsViewer } from '../../viewers/index.ts'
+import { mergedAddRemoveStakeEventsByStaker } from './mergedAddRemoveStakeEventsByStaker.ts'
+
+export async function allStakersForRange(
+  chain: StakeEventsViewer,
+  externalRange: [number, number],
+  staked: Address,
+): Promise<Record<Address, bigint>> {
+  const mergedEvents = await mergedAddRemoveStakeEventsByStaker(chain, [0, externalRange[1]], staked)
+  const resultWithZeros: Record<Address, bigint> = {}
+  for (const event of mergedEvents) {
+    const staker = toAddress(event.args.staker)
+    resultWithZeros[staker] = resultWithZeros[staker] ?? 0n
+    if (event.name === 'StakeAdded') {
+      resultWithZeros[staker] += event.args.amount
+    } else if (event.name === 'StakeRemoved') {
+      resultWithZeros[staker] -= event.args.amount
+    }
+  }
+  const nonZero = Object.entries(resultWithZeros).filter(([, amount]) => amount > 0n).map(([address]) => address)
+  const result: Record<Address, bigint> = {}
+  for (const address of nonZero) {
+    result[toAddress(address)] = resultWithZeros[toAddress(address)]
+  }
+  return result
+}

package/src/primitives/stake/allStakersForStep.ts

@@ -0,0 +1,22 @@
+import { type Address } from '@xylabs/sdk-js'
+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 { stepBlockRange } from '../step/index.ts'
+import { allStakersForRange } from './allStakersForRange.ts'
+
+export async function allStakersForStep(
+  context: StakedChainContextRead,
+  blockViewer: BlockViewer,
+  stepContext: StepIdentity,
+  staked: Address,
+): Promise<Record<Address, bigint>> {
+  const xl1BlockRange = stepBlockRange(stepContext)
+  return await allStakersForRange(
+    context.stake.stakeEvents,
+    await externalBlockRangeFromXL1BlockRange(context, blockViewer, xl1BlockRange),
+    staked,
+  )
+}

package/src/primitives/stake/index.ts

@@ -0,0 +1,6 @@
+export * from './activeStakeAtTimeByAddress.ts'
+export * from './activeStakeAtTimeByPosition.ts'
+export * from './allStakersForRange.ts'
+export * from './allStakersForStep.ts'
+export * from './mergedAddRemoveStakeEventsByPosition.ts'
+export * from './weightedStakeForRangeByPosition.ts'

package/src/primitives/stake/mergedAddRemoveStakeEventsByPosition.ts

@@ -0,0 +1,14 @@
+import type { StakeEvent, StakeEventsViewer } from '../../viewers/index.ts'
+
+export async function mergedAddRemoveStakeEventsByPosition(
+  chainEvents: StakeEventsViewer,
+  range: [number, number],
+  position?: number,
+): Promise<(StakeEvent<'StakeAdded'> | StakeEvent<'StakeRemoved'>)[]> {
+  const [addedEvents, removedEvents] = await Promise.all([
+    chainEvents.stakeEvents(range, { name: 'StakeAdded', args: { id: position } }),
+    chainEvents.stakeEvents(range, { name: 'StakeRemoved', args: { id: position } }),
+  ])
+  const result = [...addedEvents, ...removedEvents].toSorted((a, b) => a.time - b.time)
+  return result
+}

package/src/primitives/stake/mergedAddRemoveStakeEventsByStaker.ts

@@ -0,0 +1,17 @@
+import type { Address } from '@xylabs/sdk-js'
+
+import type { StakeEvent, StakeEventsViewer } from '../../viewers/index.ts'
+
+export async function mergedAddRemoveStakeEventsByStaker(
+  chainEvents: StakeEventsViewer,
+  range: [number, number],
+  staked: Address,
+  staker?: Address,
+): Promise<(StakeEvent<'StakeAdded'> | StakeEvent<'StakeRemoved'>)[]> {
+  const [addedEvents, removedEvents] = await Promise.all([
+    chainEvents.stakeEvents(range, { name: 'StakeAdded', args: { staked, staker } }),
+    chainEvents.stakeEvents(range, { name: 'StakeRemoved', args: { staked, staker } }),
+  ])
+  const result = [...addedEvents, ...removedEvents].toSorted((a, b) => a.time - b.time)
+  return result
+}

package/src/primitives/stake/weightedStakeForRangeByPosition.ts

@@ -0,0 +1,54 @@
+import { isDefined } from '@xylabs/sdk-js'
+import { asBlockNumber, type BlockRange } from '@xyo-network/xl1-protocol'
+
+import { type StakedChainContextRead, withContextCacheResponse } from '../../model/index.ts'
+import type { BlockViewer } from '../../viewers/index.ts'
+import { mergedAddRemoveStakeEventsByPosition } from './mergedAddRemoveStakeEventsByPosition.ts'
+
+export async function weightedStakeForRangeByPosition(
+  context: StakedChainContextRead,
+  blockViewer: BlockViewer,
+  externalRange: BlockRange, // first to last block of step
+  positionId?: number,
+): Promise<bigint> {
+  const cacheKey = isDefined(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`
+  return await withContextCacheResponse(context, 'weightedStakeForRangeByPosition', cacheKey, async () => {
+    let weightedStakeSum = 0n
+    if (isDefined(positionId)) {
+      const mergedEvents = (await mergedAddRemoveStakeEventsByPosition(
+        context.stake.stakeEvents,
+        [0, externalRange[1]],
+        positionId,
+      )).toSorted((a, b) => a.time - b.time)
+      let currentTime = externalRange[0]
+      let currentStake = 0n // await activeStakeAtTimeByPosition(chainEvents, pos.staked, currentTime - 1, position)
+      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
+          weightedStakeSum += currentStake * BigInt(event.time - currentTime)
+        }
+        if (event.name === 'StakeAdded') {
+          currentStake += event.args.amount
+        } else if (event.name === 'StakeRemoved') {
+          currentStake -= event.args.amount
+        }
+        // seems that sometimes we get multiple remove events, so ensure stake doesn't go negative
+        currentStake = currentStake < 0n ? 0n : currentStake
+        currentTime = asBlockNumber(event.time, { name: 'weightedStakeForRangeByPosition' })
+        if (currentTime > externalRange[1]) {
+          break
+        }
+      }
+      if (externalRange[1] > currentTime) {
+        // Add the weighted stake for the period between the last event and the end of the range
+        weightedStakeSum += currentStake * BigInt(externalRange[1] - currentTime)
+      }
+    } else {
+      const positionCount = await context.stake.stakeEvents.positionCount(externalRange)
+      for (let pos = 0; pos < positionCount; pos++) {
+        weightedStakeSum += await weightedStakeForRangeByPosition(context, blockViewer, externalRange, pos)
+      }
+    }
+    return weightedStakeSum
+  })
+}

package/src/provider/DataLake.ts

@@ -2,24 +2,25 @@ import type { Hash } from '@xylabs/sdk-js'
 import type { Payload, Schema } from '@xyo-network/payload-model'
 
 import type { MapType } from '../map/index.ts'
+import type { Provider } from '../model/index.ts'
 
 export type DataLakeData = Payload | ArrayBuffer
 
-export type DataLakeViewerMethods = Pick<MapType<Hash, DataLakeData>, 'get' | 'getMany' | 'has'>
-
-export interface DataLakeViewer extends DataLakeViewerMethods {
-  allowedSchemas?: Schema[]
-  disallowedSchemas?: Schema[]
-}
-
 export const DataLakeViewerMoniker = 'DataLakeViewer' as const
 export type DataLakeViewerMoniker = typeof DataLakeViewerMoniker
 
-export type DataLakeRunnerMethods = Pick<MapType<Hash, DataLakeData>, 'set' | 'delete' | 'clear'> & {
-  setMany(entries: [Hash, DataLakeData][]): Promise<void>
-}
+export interface DataLakeViewerMethods extends
+  Pick<MapType<Hash, DataLakeData>, 'get' | 'getMany' | 'has'> {}
 
-export interface DataLakeRunner extends DataLakeRunnerMethods {}
+export interface DataLakeViewer extends DataLakeViewerMethods, Provider<DataLakeViewerMoniker> {
+  allowedSchemas?: Schema[]
+  disallowedSchemas?: Schema[]
+}
 
 export const DataLakeRunnerMoniker = 'DataLakeRunner' as const
 export type DataLakeRunnerMoniker = typeof DataLakeRunnerMoniker
+
+export interface DataLakeRunnerMethods extends Pick<MapType<Hash, DataLakeData>, 'setMany' | 'set' | 'delete' | 'clear'>,
+  DataLakeViewerMethods {}
+
+export interface DataLakeRunner extends DataLakeRunnerMethods, Provider<DataLakeRunnerMoniker> {}

package/src/provider/XyoConnection.ts

@@ -1,9 +1,13 @@
+import type { Provider } from '../model/index.ts'
 import type { DataLakeRunner, DataLakeViewer } from './DataLake.ts'
 import type { NetworkStakeViewer, XyoViewer } from './viewer/index.ts'
 import type { XyoNetwork } from './XyoNetwork.ts'
 import type { XyoRunner } from './XyoRunner.ts'
 
-export interface XyoConnection {
+export const XyoConnectionMoniker = 'XyoConnection' as const
+export type XyoConnectionMoniker = typeof XyoConnectionMoniker
+
+export interface XyoConnection extends Provider<XyoConnectionMoniker> {
   network?: XyoNetwork
   networkStake?: NetworkStakeViewer
   runner?: XyoRunner

package/src/provider/XyoGatewayRunner.ts

@@ -1,9 +1,9 @@
 import type {
-  Address, Hash, Hex, Promisable,
+  Address, Hash, Promisable,
 } from '@xylabs/sdk-js'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
-  AllowedBlockPayload, AttoXL1, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionFeesBigInt,
+  AllowedBlockPayload, AttoXL1, ChainId, SignedHydratedTransaction, SignedHydratedTransactionWithHashMeta, TransactionFeesBigInt,
   UnsignedHydratedTransaction,
   XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
@@ -13,7 +13,7 @@ import type { DataLakeRunner } from './DataLake.ts'
 import type { XyoGateway } from './XyoGateway.ts'
 
 export interface TransactionOptions {
-  chain?: Hex
+  chain?: ChainId
   exp?: XL1BlockNumber
   fees?: TransactionFeesBigInt
   from?: Address

package/src/provider/XyoRunner.ts

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

package/src/provider/viewer/XyoViewer.ts

@@ -9,18 +9,18 @@ import type {
   AccountBalanceViewer,
   BlockViewer,
   BlockViewerMethods,
-  ChainViewerMethods,
   ForkViewerMethods,
   MempoolViewer,
   NetworkStakeStepRewardViewerMethods,
   StakeViewerMethods,
   StepViewer,
+  TimeSyncViewer,
   TransactionViewerMethods,
 } from '../../viewers/index.ts'
 import type { NetworkStakeViewer } from './NetworkStake/index.ts'
 
 export interface XyoViewerMethods extends
-  NetworkStakeStepRewardViewerMethods, Pick<ChainViewerMethods, 'chainId'>, BlockViewerMethods,
+  NetworkStakeStepRewardViewerMethods, BlockViewerMethods,
   TransactionViewerMethods, StakeViewerMethods, ForkViewerMethods {
   accountBalance(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AttoXL1>
   accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promisable<AccountBalanceHistoryItem[]>
@@ -31,11 +31,12 @@ export type XyoViewerMoniker = typeof XyoViewerMoniker
 
 export interface XyoViewer extends Omit<BlockViewer, 'moniker'>, XyoViewerMethods,
   Omit<StakeViewerMethods, 'moniker'>, Provider<XyoViewerMoniker> {
-  account?: {
-    balance?: AccountBalanceViewer
+  account: {
+    balance: AccountBalanceViewer
   }
-  block?: BlockViewer
-  mempool?: MempoolViewer
-  networkStake?: NetworkStakeViewer
-  step?: StepViewer
+  block: BlockViewer
+  mempool: MempoolViewer
+  networkStake: NetworkStakeViewer
+  step: StepViewer
+  time: TimeSyncViewer
 }

package/src/runners/Block.ts

@@ -1,10 +1,18 @@
-import type { SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { WithHashMeta } from '@xyo-network/payload-model'
+import type {
+  BlockBoundWitness, SignedBlockBoundWitnessWithHashMeta, SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+
+import type { Provider } from '../model/index.ts'
 
 export interface BlockRunnerMethods {
   produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force: true): Promise<SignedHydratedBlockWithHashMeta>
   produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: false): Promise<SignedHydratedBlockWithHashMeta | undefined>
 }
 
-export interface BlockRunner extends BlockRunnerMethods {
+export const BlockRunnerMoniker = 'BlockRunner' as const
+export type BlockRunnerMoniker = typeof BlockRunnerMoniker
 
+export interface BlockRunner extends BlockRunnerMethods, Provider<BlockRunnerMoniker> {
+  next(head: WithHashMeta<BlockBoundWitness>): Promise<SignedHydratedBlockWithHashMeta | undefined>
 }

package/src/runners/Mempool.ts

@@ -1,9 +1,14 @@
 import type { Hash } from '@xylabs/sdk-js'
 import type { SignedHydratedBlock, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 
+import type { Provider } from '../model/index.ts'
+
 export interface MempoolRunnerMethods {
   submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]>
   submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]>
 }
 
-export interface MempoolRunner extends MempoolRunnerMethods {}
+export const MempoolRunnerMoniker = 'MempoolRunner' as const
+export type MempoolRunnerMoniker = typeof MempoolRunnerMoniker
+
+export interface MempoolRunner extends MempoolRunnerMethods, Provider<MempoolRunnerMoniker> {}

package/src/services/Chain/ChainService.ts

@@ -1,6 +1,4 @@
-import type {
-  ChainContractViewer, ChainStakeViewer, ChainViewer,
-} from '../../viewers/index.ts'
+import type { ChainContractViewer, ChainStakeViewer } from '../../viewers/index.ts'
 import type { BaseChainService } from './BaseChainService.ts'
 
-export interface ChainService extends Omit<ChainContractViewer, 'moniker'>, Omit<ChainStakeViewer, 'moniker'>, Omit<ChainViewer, 'moniker'>, BaseChainService {}
+export interface ChainService extends Omit<ChainContractViewer, 'moniker'>, Omit<ChainStakeViewer, 'moniker'>, BaseChainService {}

package/src/simple/accountBalance/SimpleAccountBalanceViewer.ts

@@ -16,9 +16,10 @@ import {
 import { deepCalculateFramesFromRange } from '../../block/index.ts'
 import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
 import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-import type { ProviderMoniker, Qualified } from '../../model/index.ts'
+import type { Qualified } from '../../model/index.ts'
 import type {
-  BalanceStepSummaryContext, TransfersStepSummary,
+  BalanceStepSummaryContext,
+  TransfersStepSummary,
   TransfersStepSummaryContext,
 } from '../../summary/index.ts'
 import {
@@ -28,11 +29,11 @@ import {
 import {
   type AccountBalanceHistoryItem, type AccountBalanceViewer, AccountBalanceViewerMoniker,
   type BlockViewer,
+  BlockViewerMoniker,
 } from '../../viewers/index.ts'
 
 export interface SimpleAccountBalanceViewerParams extends CreatableProviderParams {
-  blockViewer: BlockViewer
-  context: BalanceStepSummaryContext
+  balanceSummaryContext: BalanceStepSummaryContext
   transfersSummaryContext: TransfersStepSummaryContext
 }
 
@@ -42,24 +43,25 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
   static readonly monikers = [AccountBalanceViewerMoniker]
   moniker = SimpleAccountBalanceViewer.defaultMoniker
 
-  get blockViewer(): BlockViewer {
-    return this.params.blockViewer!
+  private _blockViewer?: BlockViewer
+
+  get balanceSummaryContext() {
+    return this.params.balanceSummaryContext!
   }
 
-  get context(): BalanceStepSummaryContext {
-    return this.params.context!
+  get blockViewer() {
+    return this._blockViewer!
   }
 
-  get transfersSummaryContext(): TransfersStepSummaryContext {
+  get transfersSummaryContext() {
     return this.params.transfersSummaryContext!
   }
 
-  static override async paramsHandler(params: Partial<SimpleAccountBalanceViewerParams>) {
-    assertEx(params.blockViewer, () => 'blockViewer is required')
-    assertEx(params.context, () => 'context is required')
+  static override async paramsHandler(params: Partial<SimpleAccountBalanceViewerParams> = {}) {
     assertEx(params.transfersSummaryContext, () => 'transfersSummaryContext is required')
+    assertEx(params.balanceSummaryContext, () => 'balanceSummaryContext is required')
 
-    return { ...await super.paramsHandler(params) }
+    return await super.paramsHandler({ ...params })
   }
 
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
@@ -104,6 +106,11 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
     return result
   }
 
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
+  }
+
   async qualifiedAccountBalanceHistories(
     addresses: Address[],
     headOrRange?: Hash | XL1BlockRange,
@@ -146,7 +153,7 @@ export class SimpleAccountBalanceViewer extends AbstractCreatableProvider<Simple
   ): Promise<Qualified<Record<Address, AttoXL1>>> {
     return await spanRootAsync('qualifiedAccountsBalances', async () => {
       const qualifiedSummary = await balancesSummary(
-        this.context,
+        this.balanceSummaryContext,
       )
       const result: Record<Address, AttoXL1> = {}
       for (const addr of address) {