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

package/src/simple/chainStake/{SimpleChainStakeViewer.ts → SimpleStakeViewer.ts}

@@ -2,16 +2,14 @@ import {
   type Address, asAddress, toAddress,
 } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
 
 import {
   AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
 } from '../../CreatableProvider/index.ts'
 import { PayloadMap, Position } from '../../model/index.ts'
 import {
-  StakeEventsViewer, StakeViewer, StakeViewerMoniker,
+  StakeEventsViewer, StakeEventsViewerMoniker, StakeViewer, StakeViewerMoniker,
 } from '../../viewers/index.ts'
-import { SimpleChainStakeEventsViewer } from '../chainStakeEvents/index.ts'
 
 export interface SimpleChainStakeParams extends CreatableProviderParams {
   chainId?: Address
@@ -21,18 +19,13 @@ export interface SimpleChainStakeParams extends CreatableProviderParams {
 }
 
 @creatableProvider()
-export class SimpleChainStakeViewer extends AbstractCreatableProvider<SimpleChainStakeParams> implements StakeViewer {
+export class SimpleStakeViewer extends AbstractCreatableProvider<SimpleChainStakeParams> implements StakeViewer {
   static readonly defaultMoniker = StakeViewerMoniker
   static readonly monikers = [StakeViewerMoniker]
-  moniker = SimpleChainStakeViewer.defaultMoniker
+  moniker = SimpleStakeViewer.defaultMoniker
 
-  private _chainId: Address | undefined
   private _chainStakeEventsViewer: StakeEventsViewer | undefined
 
-  get chainId(): Address {
-    return assertEx(this._chainId, () => 'Chain ID not set')
-  }
-
   get chainMap() {
     return this.params.chainMap
   }
@@ -87,6 +80,14 @@ export class SimpleChainStakeViewer extends AbstractCreatableProvider<SimpleChai
     return active
   }
 
+  override async createHandler() {
+    await super.createHandler()
+    this._chainStakeEventsViewer = assertEx(
+      (await this.locateAndCreate<StakeEventsViewer>(StakeEventsViewerMoniker)),
+      () => 'Failed to create StakeEventsViewer',
+    )
+  }
+
   pending(): bigint {
     let pending = 0n
     for (const position of this.positions) {
@@ -144,10 +145,4 @@ export class SimpleChainStakeViewer extends AbstractCreatableProvider<SimpleChai
     }
     return withdrawn
   }
-
-  protected override async startHandler(): Promise<void> {
-    await super.startHandler()
-    this._chainId = this.params.chainId ?? (await Account.random()).address
-    this._chainStakeEventsViewer = await SimpleChainStakeEventsViewer.create({ positions: this.positions })
-  }
 }

package/src/simple/chainStake/index.ts

@@ -1 +1 @@
-export * from './SimpleChainStakeViewer.ts'
+export * from './SimpleStakeViewer.ts'

package/src/simple/datalake/AbstractSimpleDataLake.ts

@@ -2,11 +2,11 @@ import type { Hash } from '@xylabs/sdk-js'
 import { isAnyPayload, type Schema } from '@xyo-network/payload-model'
 
 import { AbstractCreatableProvider, type CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import type { MapTypeRead, MapTypeWrite } from '../../map/index.ts'
+import type { MapTypeRead } from '../../map/index.ts'
 import { type DataLakeData } from '../../provider/index.ts'
 
 export interface AbstractSimpleDataLakeParams<TMap extends
-  MapTypeRead<Hash, DataLakeData> | MapTypeWrite<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData> | MapTypeWrite<Hash, DataLakeData>> extends
+MapTypeRead<Hash, DataLakeData> = MapTypeRead<Hash, DataLakeData>> extends
   CreatableProviderParams {
 
   allowedSchemas?: Schema[]
@@ -14,7 +14,8 @@ export interface AbstractSimpleDataLakeParams<TMap extends
   map: TMap
 }
 
-export class AbstractSimpleDataLake<TParams extends AbstractSimpleDataLakeParams = AbstractSimpleDataLakeParams> extends AbstractCreatableProvider<TParams> {
+export abstract class AbstractSimpleDataLake<TParams extends AbstractSimpleDataLakeParams = AbstractSimpleDataLakeParams> extends
+  AbstractCreatableProvider<TParams> {
   get allowedSchemas(): Schema[] | undefined {
     return this.params.allowedSchemas
   }
@@ -27,23 +28,23 @@ export class AbstractSimpleDataLake<TParams extends AbstractSimpleDataLakeParams
     return this.params.map
   }
 
-  // async get(hash: Hash): Promise<DataLakeData | undefined> {
-  //   const result = await this.map.get(hash)
-  //   return this.isAllowed(result) ? result : undefined
-  // }
+  async get(hash: Hash): Promise<DataLakeData | undefined> {
+    const result = await this.map.get(hash)
+    return this.isAllowed(result) ? result : undefined
+  }
 
-  // async getMany(hashes: Hash[]): Promise<DataLakeData[]> {
-  //   const result = await this.map.getMany(hashes)
-  //   return result.filter(data => this.isAllowed(data))
-  // }
+  async getMany(hashes: Hash[]): Promise<DataLakeData[]> {
+    const result = await this.map.getMany(hashes)
+    return result.filter(data => this.isAllowed(data))
+  }
 
-  // async has(hash: Hash): Promise<boolean> {
-  //   const value = await this.get(hash)
-  //   if (isAnyPayload(value)) {
-  //     return this.isAllowed(value)
-  //   }
-  //   return value !== undefined
-  // }
+  async has(hash: Hash): Promise<boolean> {
+    const value = await this.get(hash)
+    if (isAnyPayload(value)) {
+      return this.isAllowed(value)
+    }
+    return value !== undefined
+  }
 
   protected isAllowed(value: DataLakeData | undefined): boolean {
     if (isAnyPayload(value)) {

package/src/simple/datalake/SimpleDataLakeRunner.ts

@@ -1,15 +1,16 @@
 import type { Hash } from '@xylabs/sdk-js'
 
 import { creatableProvider } from '../../CreatableProvider/index.ts'
-import type { MapTypeWrite } from '../../map/index.ts'
+import type { MapType } from '../../map/index.ts'
 import {
   type DataLakeData,
   type DataLakeRunner,
   DataLakeRunnerMoniker,
 } from '../../provider/index.ts'
-import { AbstractSimpleDataLake, AbstractSimpleDataLakeParams } from './AbstractSimpleDataLake.ts'
+import { AbstractSimpleDataLake } from './AbstractSimpleDataLake.ts'
+import { DataLakeViewerParams } from './SimpleDataLakeViewer.ts'
 
-export interface DataLakeRunnerParams extends AbstractSimpleDataLakeParams<MapTypeWrite<Hash, DataLakeData>> {}
+export interface DataLakeRunnerParams extends DataLakeViewerParams<MapType<Hash, DataLakeData>> {}
 
 @creatableProvider()
 export class SimpleDataLakeRunner<TParams extends DataLakeRunnerParams> extends

package/src/simple/datalake/SimpleDataLakeViewer.ts

@@ -1,5 +1,4 @@
 import type { Hash } from '@xylabs/sdk-js'
-import { isAnyPayload } from '@xyo-network/payload-model'
 
 import { creatableProvider } from '../../CreatableProvider/index.ts'
 import type { MapTypeRead } from '../../map/index.ts'
@@ -20,22 +19,4 @@ export class SimpleDataLakeViewer<TParams extends DataLakeViewerParams = DataLak
   static readonly defaultMoniker = DataLakeViewerMoniker
   static readonly monikers = [DataLakeViewerMoniker]
   moniker = SimpleDataLakeViewer.defaultMoniker
-
-  async get(hash: Hash): Promise<DataLakeData | undefined> {
-    const result = await this.map.get(hash)
-    return this.isAllowed(result) ? result : undefined
-  }
-
-  async getMany(hashes: Hash[]): Promise<DataLakeData[]> {
-    const result = await this.map.getMany(hashes)
-    return result.filter(data => this.isAllowed(data))
-  }
-
-  async has(hash: Hash): Promise<boolean> {
-    const value = await this.get(hash)
-    if (isAnyPayload(value)) {
-      return this.isAllowed(value)
-    }
-    return value !== undefined
-  }
 }

package/src/simple/index.ts

@@ -1,6 +1,7 @@
 export * from './accountBalance/index.ts'
 export * from './block/index.ts'
 export * from './blockReward/index.ts'
+export * from './blockValidation/index.ts'
 export * from './chainStake/index.ts'
 export * from './client/index.ts'
 export * from './datalake/index.ts'
@@ -10,4 +11,5 @@ export * from './network/index.ts'
 export * from './permissions/index.ts'
 export * from './runner/index.ts'
 export * from './signer/index.ts'
+export * from './stakeEvents/index.ts'
 export * from './timesync/index.ts'

package/src/simple/mempool/SimpleMempoolRunner.ts

@@ -1,20 +1,25 @@
-import {
-  AbstractCreatable, creatable, CreatableParams, type Hash,
-} from '@xylabs/sdk-js'
+import { type Hash } from '@xylabs/sdk-js'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { type SignedHydratedBlock, type SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 
+import {
+  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
+} from '../../CreatableProvider/index.ts'
 import { hydratedBlockToPayloadBundle, hydratedTransactionToPayloadBundle } from '../../model/index.ts'
-import type { MempoolRunner } from '../../runners/index.ts'
+import { type MempoolRunner, MempoolRunnerMoniker } from '../../runners/index.ts'
 
-export interface SimpleMempoolRunnerParams extends CreatableParams {
+export interface SimpleMempoolRunnerParams extends CreatableProviderParams {
   pendingBlocksArchivist: ArchivistInstance
   pendingTransactionsArchivist: ArchivistInstance
 }
 
-@creatable()
-export class SimpleMempoolRunner extends AbstractCreatable<SimpleMempoolRunnerParams> implements MempoolRunner {
+@creatableProvider()
+export class SimpleMempoolRunner extends AbstractCreatableProvider<SimpleMempoolRunnerParams> implements MempoolRunner {
+  static readonly defaultMoniker = MempoolRunnerMoniker
+  static readonly monikers = [MempoolRunnerMoniker]
+  moniker = SimpleMempoolRunner.defaultMoniker
+
   protected get pendingBlocksArchivist() {
     return this.params.pendingBlocksArchivist
   }
@@ -41,7 +46,7 @@ export class SimpleMempoolRunner extends AbstractCreatable<SimpleMempoolRunnerPa
         await PayloadBuilder.addHashMeta(payloads),
       ])
     }))
-    const inserted = await this.pendingBlocksArchivist.insert(bundles)
+    const inserted = await this.pendingTransactionsArchivist.insert(bundles)
     return inserted.map(p => p._hash)
   }
 }

package/src/simple/mempool/SimpleMempoolViewer.ts

@@ -58,10 +58,15 @@ export class SimpleMempoolViewer extends AbstractCreatableProvider<SimpleMempool
         cursor = p._sequence
       }
     }
+    this.logger?.info(`Fetching pending transactions from cursor: ${cursor}`)
     const bundles = await this.pendingTransactionsArchivist.next({
       order: 'asc', limit: 100, cursor,
     })
+    this.logger?.info(`Fetched pending transactions: ${bundles.length} bundles`)
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta)
-    return (await Promise.all(filteredBundles.map(async bundle => await bundledPayloadToHydratedTransaction(bundle)))).filter(exists)
+    this.logger?.info(`Filtered pending transactions: ${JSON.stringify(bundles, null, 2)} filteredBundles`)
+    const result = (await Promise.all(filteredBundles.map(async bundle => await bundledPayloadToHydratedTransaction(bundle)))).filter(exists)
+    this.logger?.info(`Converted pending transactions: ${JSON.stringify(result, null, 2)} results`)
+    return result
   }
 }

package/src/simple/runner/SimpleXyoRunner.ts

@@ -1,29 +1,54 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import {
+  assertEx,
+  type Hash,
+} from '@xylabs/sdk-js'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
 
-import type { XyoRunner } from '../../provider/index.ts'
-import { flattenHydratedTransaction } from '../../transaction/index.ts'
+import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
+import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
+import { hydratedTransactionToPayloadBundle } from '../../model/index.ts'
+import { type XyoRunner, XyoRunnerMoniker } from '../../provider/index.ts'
+import { type MempoolRunner, MempoolRunnerMoniker } from '../../runners/index.ts'
 
-export class SimpleXyoRunner implements XyoRunner {
-  private _mempoolArchivist?: ArchivistInstance
+export interface SimpleXyoRunnerParams extends CreatableProviderParams {
+  pendingTransactionsArchivist: ArchivistInstance
+}
+
+export class SimpleXyoRunner extends AbstractCreatableProvider<SimpleXyoRunnerParams> implements XyoRunner {
+  static readonly defaultMoniker = XyoRunnerMoniker
+  static readonly monikers = [XyoRunnerMoniker]
+  moniker = SimpleXyoRunner.defaultMoniker
 
-  constructor(mempoolArchivist?: ArchivistInstance) {
-    this._mempoolArchivist = mempoolArchivist
+  private _mempoolRunner?: MempoolRunner
+
+  get mempool() {
+    return this._mempoolRunner!
+  }
+
+  static override async paramsHandler(params?: SimpleXyoRunnerParams) {
+    return {
+      ...await super.paramsHandler(params),
+      pendingTransactionsArchivist: assertEx(
+        params?.pendingTransactionsArchivist,
+        () => 'A pendingTransactionsArchivist is required to create a SimpleXyoRunner',
+      ),
+    }
   }
 
   async broadcastTransaction(transaction: SignedHydratedTransactionWithStorageMeta): Promise<Hash> {
-    const archivist = await this.getMempoolArchivist()
-    await archivist.insert(flattenHydratedTransaction(transaction))
-    return await PayloadBuilder.hash(transaction[0])
+    const archivist = this.params.pendingTransactionsArchivist
+    const bundle = hydratedTransactionToPayloadBundle(transaction)
+    await archivist.insert([bundle])
+    await this.mempool.submitTransactions([transaction])
+    const hash = await PayloadBuilder.hash(transaction[0])
+    this.logger?.info(`Broadcasted transaction with hash ${hash}`)
+    return hash
   }
 
-  protected async getMempoolArchivist(): Promise<ArchivistInstance> {
-    if (!this._mempoolArchivist) {
-      this._mempoolArchivist = await MemoryArchivist.create({ account: 'random' })
-    }
-    return this._mempoolArchivist
+  override async createHandler() {
+    await super.createHandler()
+    this._mempoolRunner = await this.locator.getInstance<MempoolRunner>(MempoolRunnerMoniker)
   }
 }

package/src/simple/{chainStakeEvents/SimpleChainStakeEventsViewer.ts → stakeEvents/SimpleStakeEventsViewer.ts}

@@ -9,15 +9,15 @@ import {
   StakeEventsViewerMoniker,
 } from '../../viewers/index.ts'
 
-export interface SimpleChainStakeEventsParams extends CreatableProviderParams {
+export interface SimpleStakeEventsParams extends CreatableProviderParams {
   positions: Position[]
 }
 
 @creatableProvider()
-export class SimpleChainStakeEventsViewer extends AbstractCreatableProvider<SimpleChainStakeEventsParams> implements StakeEventsViewer {
+export class SimpleStakeEventsViewer extends AbstractCreatableProvider<SimpleStakeEventsParams> implements StakeEventsViewer {
   static readonly defaultMoniker = StakeEventsViewerMoniker
   static readonly monikers = [StakeEventsViewerMoniker]
-  moniker = SimpleChainStakeEventsViewer.defaultMoniker
+  moniker = SimpleStakeEventsViewer.defaultMoniker
 
   protected get positions() {
     return this.params.positions
@@ -84,9 +84,9 @@ export class SimpleChainStakeEventsViewer extends AbstractCreatableProvider<Simp
   private positionsFromRange(range: [number, number | 'latest']): Position[] {
     const startBlock = range[0]
     const endBlock = range[1] === 'latest' ? Number.MAX_SAFE_INTEGER : range[1]
-    const filteredPositions = this.positions.filter((position) => {
+    const filteredPositions = this.positions?.filter((position) => {
       return position.addBlock <= endBlock && (position.removeBlock === 0 || position.removeBlock >= startBlock)
-    })
+    }) ?? []
     return filteredPositions
   }
 }

package/src/simple/stakeEvents/index.ts

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

package/src/simple/timesync/SimpleTimeSyncViewer.ts

@@ -1,4 +1,4 @@
-import type { Hash, Promisable } from '@xylabs/sdk-js'
+import type { Hash } from '@xylabs/sdk-js'
 import {
   asHash, assertEx, isDefined,
 } from '@xylabs/sdk-js'
@@ -11,11 +11,10 @@ import type { Provider } from 'ethers'
 import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
 import { AbstractCreatableProvider } from '../../CreatableProvider/index.ts'
 import {
-  type BlockViewer, type TimeSyncViewer, TimeSyncViewerMoniker,
+  type BlockViewer, BlockViewerMoniker, type TimeSyncViewer, TimeSyncViewerMoniker,
 } from '../../viewers/index.ts'
 
 export interface SimpleTimeSyncViewerParams extends CreatableProviderParams {
-  blockViewer: BlockViewer
   ethProvider?: Provider
 }
 
@@ -24,8 +23,10 @@ export class SimpleTimeSyncViewer extends AbstractCreatableProvider<SimpleTimeSy
   static readonly monikers = [TimeSyncViewerMoniker]
   moniker = SimpleTimeSyncViewer.defaultMoniker
 
+  private _blockViewer?: BlockViewer
+
   protected get blockViewer() {
-    return this.params.blockViewer
+    return this._blockViewer!
   }
 
   protected get ethProvider() {
@@ -61,6 +62,11 @@ export class SimpleTimeSyncViewer extends AbstractCreatableProvider<SimpleTimeSy
     }
   }
 
+  override async createHandler() {
+    await super.createHandler()
+    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
+  }
+
   async currentTime(domain: TimeDomain): Promise<[string, number]> {
     switch (domain) {
       case 'xl1': {
@@ -100,7 +106,22 @@ export class SimpleTimeSyncViewer extends AbstractCreatableProvider<SimpleTimeSy
     }
   }
 
-  currentTimePayload(): Promisable<TimePayload> {
-    throw new Error('Method [currentTimePayload] not implemented.')
+  async currentTimePayload(): Promise<TimePayload> {
+    const [xl1, xl1Hash] = await this.currentTimeAndHash('xl1')
+    const timePayload: TimePayload = {
+      schema: TimeSchema,
+      // this is for the previous block
+      xl1,
+      // this is for the previous block
+      xl1Hash: assertEx(xl1Hash, () => 'No xl1 hash available from time sync service'),
+      epoch: Date.now(),
+    }
+    if (isDefined(this.ethProvider)) {
+      const [ethereum, ethHashOrNull] = await this.currentTimeAndHash('ethereum')
+      const ethereumHash = asHash(ethHashOrNull, () => 'No ethereum hash available from time sync service')
+      timePayload.ethereum = ethereum
+      timePayload.ethereumHash = ethereumHash
+    }
+    return timePayload
   }
 }

package/src/status/RuntimeStatusMonitor.ts

@@ -0,0 +1,117 @@
+import type { CreatableName, CreatableStatus } from '@xylabs/sdk-js'
+
+import { LoggerStatusReporter } from './ServiceStatus.ts'
+
+/**
+ * Enum-like record for statuses with priority allowing
+ * for determination of the aggregated status.
+ */
+const statusPriority: Record<CreatableStatus, number> = {
+  error: 0,
+  stopped: 1,
+  stopping: 2,
+  creating: 3,
+  created: 4,
+  starting: 5,
+  started: 6,
+}
+
+/**
+ * A sentinel status that represents the initial state
+ * before any statuses are reported.
+ * It is used to ensure that the monitor has a valid status
+ * even when no statuses have been reported yet and to
+ * prevent the system from showing an "error" state
+ * when no statuses are available.
+ */
+const SENTINEL_STATUS: CreatableStatus = 'starting'
+
+/**
+ * Given an array of statuses, this function reduces them
+ * to the minimum status based on the defined priority.
+ * @param statuses An array of statuses to reduce.
+ * @returns The minimum status based on priority.
+ */
+const reduceToMinimumStatus = (statuses: CreatableStatus[]): CreatableStatus => {
+  let minStatus: CreatableStatus = SENTINEL_STATUS
+  let minPriority = Infinity
+
+  for (const status of statuses) {
+    const priority = statusPriority[status]
+    if (priority < minPriority) {
+      minPriority = priority
+      minStatus = status
+    }
+  }
+  return minStatus
+}
+
+export type GlobalTransitionHandler = {
+  from?: CreatableStatus
+  handler: (from: CreatableStatus, to: CreatableStatus) => void
+  to?: CreatableStatus
+}
+export type TransitionHandler = GlobalTransitionHandler & {
+  name?: string
+}
+
+export class RuntimeStatusMonitor extends LoggerStatusReporter {
+  private globalTransitions: GlobalTransitionHandler[] = []
+  private transitions: TransitionHandler[] = []
+
+  getGlobalStatus(): CreatableStatus {
+    // If no statuses have been reported, return the sentinel status
+    if (Object.keys(this.statusMap).length === 0) return SENTINEL_STATUS
+    return reduceToMinimumStatus(Object.values(this.statusMap))
+  }
+
+  getStatus(name: CreatableName): CreatableStatus | undefined {
+    return this.statusMap[name]
+  }
+
+  onGlobalTransition(match: { from?: CreatableStatus; to?: CreatableStatus }, handler: (from: CreatableStatus, to: CreatableStatus) => void) {
+    this.globalTransitions.push({ ...match, handler })
+  }
+
+  /**
+   * Register a callback to be called on a specific transition.
+   */
+  onTransition(match: { from?: CreatableStatus; name: string; to?: CreatableStatus }, handler: (from: CreatableStatus, to: CreatableStatus) => void) {
+    this.transitions.push({ ...match, handler })
+  }
+
+  override report(name: CreatableName, status: CreatableStatus, progress?: number | Error): void {
+    // Capture the current status before updating
+    const previous = this.statusMap[name]
+    const previousGlobal = this.getGlobalStatus()
+
+    // Update the status map with the new status
+    super.report(name, status, progress)
+
+    // If the status hasn't changed, do not run handlers
+    if (previous === status) return
+    this.runTransitions(this.transitions, previous, status, name)
+
+    // If the global status hasn't changed, do not run handlers
+    const globalStatus = this.getGlobalStatus()
+    if (previousGlobal === globalStatus) return
+    this.runTransitions(this.globalTransitions, previousGlobal, globalStatus)
+  }
+
+  private runTransitions(
+    transitions: (TransitionHandler | GlobalTransitionHandler)[],
+    prev: CreatableStatus,
+    next: CreatableStatus,
+    name?: string,
+  ) {
+    for (const {
+      from, to, name: matchName, handler,
+    } of transitions as TransitionHandler[]) {
+      if ((matchName === undefined || matchName === name)
+        && (from === undefined || from === prev)
+        && (to === undefined || to === next)) {
+        handler(prev, next)
+      }
+    }
+  }
+}

package/src/status/ServiceStatus.ts

@@ -0,0 +1,20 @@
+import type {
+  CreatableName, CreatableStatus, CreatableStatusReporter, Logger,
+} from '@xylabs/sdk-js'
+
+export class LoggerStatusReporter implements CreatableStatusReporter {
+  protected logger: Logger
+
+  protected statusMap: Record<CreatableName, CreatableStatus> = {}
+
+  constructor(logger: Logger) {
+    this.logger = logger
+  }
+
+  report(name: CreatableName, status: CreatableStatus, progress?: number | Error): void {
+    this.statusMap[name] = status
+    const starting = (Object.entries(this.statusMap).map(([, value]): number => value === 'starting' ? 1 : 0)).reduce((a, b) => a + b, 0)
+    const started = (Object.entries(this.statusMap).map(([, value]): number => value === 'started' ? 1 : 0)).reduce((a, b) => a + b, 0)
+    this.logger.info(`${started}/${starting + started} ${name} status: ${status}`, { progress })
+  }
+}

package/src/status/index.ts

@@ -0,0 +1,2 @@
+export * from './RuntimeStatusMonitor.ts'
+export * from './ServiceStatus.ts'

package/src/summary/model/summary.ts

@@ -1,22 +1,23 @@
 import type { Payload } from '@xyo-network/payload-model'
 import type { Semaphore } from 'async-mutex'
 
-import type { MapTypeRead, MapTypeWrite } from '../../map/index.ts'
-import type { BaseContext, ChainContextRead } from '../../model/index.ts'
+import type { MapType, MapTypeRead } from '../../map/index.ts'
+import type {
+  BaseContext, ChainContext, ChainContextRead,
+} from '../../model/index.ts'
 import type {
   BalancesStepSummary, SchemasStepSummary, TransfersStepSummary,
 } from './index.ts'
 
 export interface ChainSummaryContextBase<TPayload extends Payload,
-  T extends (MapTypeRead<string, TPayload> | MapTypeWrite<string, TPayload>)> extends BaseContext {
+  T extends (MapTypeRead<string, TPayload>)> extends BaseContext {
   stepSemaphores: Semaphore[]
   summaryMap: T
-  windowSize?: number
 }
 
 export interface ChainSummaryContextRead<T extends Payload> extends ChainSummaryContextBase<T, MapTypeRead<string, T>>, ChainContextRead {}
 
-export interface ChainSummaryContextWrite<T extends Payload> extends ChainSummaryContextBase<T, MapTypeWrite<string, T>>, ChainContextRead {}
+export interface ChainSummaryContextWrite<T extends Payload> extends ChainSummaryContextBase<T, MapType<string, T>>, ChainContext {}
 
 export type ChainSummaryContext<T extends Payload> = ChainSummaryContextRead<T> & ChainSummaryContextWrite<T>
 

package/src/summary/primitives/balances/balancesStepSummaryFromRange.ts

@@ -15,9 +15,8 @@ import { netBalancesForPayloads } from '../../../payloads/index.ts'
 import {
   parseSignedBigInt, type SignedBigInt, toSignedBigInt,
 } from '../../../SignedBigInt.ts'
-import {
-  type BalancesStepSummary, BalancesStepSummarySchema, type BalanceStepSummaryContext,
-} from '../../model/index.ts'
+import type { BalancesStepSummary, BalanceStepSummaryContext } from '../../model/index.ts'
+import { BalancesStepSummarySchema } from '../../model/index.ts'
 
 export async function balancesStepSummaryFromRange(
   context: BalanceStepSummaryContext,