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

package/src/simple/block/SimpleBlockViewer.ts

@@ -3,6 +3,7 @@ import {
   assertEx,
   exists,
   isDefined,
+  isUndefined,
   spanRootAsync,
 } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
@@ -10,6 +11,7 @@ import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 import {
   asSignedHydratedBlockWithHashMeta,
   asXL1BlockNumber,
+  ChainId,
   type SignedHydratedBlockWithHashMeta,
   type XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
@@ -22,12 +24,13 @@ import type {
   ChainContextRead,
   ChainStoreRead, PayloadMap,
 } from '../../model/index.ts'
-import { findMostRecentBlock, hydratedBlockByNumber } from '../../primitives/index.ts'
+import {
+  findMostRecentBlock, hydratedBlockByNumber, readPayloadMapFromStore,
+} from '../../primitives/index.ts'
 import { HydratedCache } from '../../utils/index.ts'
 import { type BlockViewer, BlockViewerMoniker } from '../../viewers/index.ts'
 
 export interface SimpleBlockViewerParams extends CreatableProviderParams {
-  context: ChainContextRead
   finalizedArchivist: ReadArchivist
 }
 
@@ -37,27 +40,25 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
   static readonly monikers = [BlockViewerMoniker]
   moniker = SimpleBlockViewer.defaultMoniker
 
+  protected _store: ChainStoreRead | undefined
+
   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
+    const chainMap = this.store.chainMap
     this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithHashMeta>(chainMap, async (
-      { chainMap }: ChainStoreRead,
+      store: ChainStoreRead,
       hash: Hash,
       maxDepth?: number,
       minDepth?: number,
     ) => {
-      const result = await hydrateBlock({ chainMap }, hash, maxDepth, minDepth)
+      const result = await hydrateBlock(store, hash, maxDepth, minDepth)
       return asSignedHydratedBlockWithHashMeta(result, true)
     }, 200)
     return this._signedHydratedBlockCache
@@ -69,8 +70,11 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
     return this._payloadCache
   }
 
+  protected get store() {
+    return this._store!
+  }
+
   static override async paramsHandler(params: Partial<SimpleBlockViewerParams>) {
-    assertEx(params.context, () => 'context is required')
     assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required')
 
     return { ...await super.paramsHandler(params) }
@@ -85,7 +89,18 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
 
   async blockByNumber(blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
     return await spanRootAsync('blockByNumber', async () => {
-      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber(this.context, blockNumber)) ?? null
+      const head = await this.getCurrentHead()
+      if (isUndefined(head)) {
+        return null
+      }
+      return asSignedHydratedBlockWithHashMeta(await hydratedBlockByNumber({
+        chainId: head.chain,
+        head: () => {
+          return [head._hash, head.block]
+        },
+        store: this.store,
+        singletons: this.context.singletons,
+      } satisfies ChainContextRead, blockNumber)) ?? null
     }, this.tracer)
   }
 
@@ -121,9 +136,27 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
     }, this.tracer)
   }
 
+  chainId(): Promise<ChainId>
+  chainId(blockNumber: XL1BlockNumber): Promise<ChainId>
+  chainId(blockNumber: 'latest'): Promise<ChainId>
+  async chainId(blockNumber: XL1BlockNumber | 'latest' = 'latest'): Promise<ChainId> {
+    return await spanRootAsync('chainId', async () => {
+      const block = assertEx(
+        blockNumber === 'latest' ? await this.currentBlock() : await this.blockByNumber(blockNumber),
+        () => `Could not find block for block number ${blockNumber}`,
+      )
+      return block[0].chain
+    })
+  }
+
+  override async createHandler() {
+    await super.createHandler()
+    this._store = { chainMap: readPayloadMapFromStore(this.params.finalizedArchivist) }
+  }
+
   async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
     return await spanRootAsync('currentBlock', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlock]')
       const cache = this.hydratedBlockCache
       const block = await cache.get(currentHead._hash)
       if (!block) {
@@ -135,14 +168,14 @@ export class SimpleBlockViewer extends AbstractCreatableProvider<SimpleBlockView
 
   async currentBlockHash(): Promise<Hash> {
     return await spanRootAsync('currentBlockHash', async () => {
-      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlockHash]')
       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')
+      const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block [currentBlockNumber]')
       return asXL1BlockNumber(currentHead.block, { name: 'currentBlockNumber' })
     }, this.tracer)
   }

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[]
@@ -27,23 +27,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

@@ -20,22 +20,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

@@ -10,4 +10,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

@@ -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)
+      }
+    }
+  }
+}