@xyo-network/xl1-cli-lib 1.7.4

package/src/orchestration/repository/lib/repositoryFromArchivist.ts

@@ -0,0 +1,27 @@
+import { filterAs } from '@xylabs/array'
+import type { Hash } from '@xylabs/hex'
+import type { AnyNonPromise } from '@xylabs/promise'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import type { PayloadRepository } from '@xyo-network/xl1-protocol'
+
+export const repositoryFromArchivist = <T extends Payload = Payload>(
+  archivist: ArchivistInstance,
+  predicate: (value: AnyNonPromise) => WithStorageMeta<T>) => {
+  const repository: PayloadRepository<Hash, WithStorageMeta<T>> = {
+    get: async (hashes: Hash[]) => {
+      const payloads = await archivist.get(hashes)
+      const filtered = filterAs(payloads, predicate)
+      return filtered
+    },
+    insert: async (payloads: T[]) => {
+      const filtered = filterAs(payloads, predicate)
+      await archivist.insert(filtered)
+      return filtered
+    },
+    next: () => {
+      throw new Error('Not implemented')
+    },
+  }
+  return repository
+}

package/src/orchestration/services/implementation/account.ts

@@ -0,0 +1,24 @@
+import type { Promisable } from '@xylabs/promise'
+import { isUndefined } from '@xylabs/typeof'
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/chain-protocol'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+
+let accountServiceSingleton: Promisable<WalletInstance> | undefined
+
+export const initAccount: Initializable<InitializableParams<{ config: Config }>, WalletInstance> = async ({ config, logger }): Promise<WalletInstance> => {
+  if (accountServiceSingleton) return accountServiceSingleton
+  let walletPhrase = config.producer.mnemonic
+  if (isUndefined(walletPhrase)) {
+    logger?.log('No wallet mnemonic specified!')
+    const randomMnemonic = HDWallet.generateMnemonic()
+    logger?.log(`Using randomly generated mnemonic: ${randomMnemonic}`)
+    walletPhrase = randomMnemonic
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase)
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO)
+  accountServiceSingleton = account
+  return accountServiceSingleton
+}

package/src/orchestration/services/implementation/balance.ts

@@ -0,0 +1,13 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BaseAccountBalanceServiceParams } from '@xyo-network/chain-services'
+import { BaseAccountBalanceService } from '@xyo-network/chain-services'
+import type { AccountBalanceServiceV2, Initializable } from '@xyo-network/xl1-protocol'
+
+let balanceServiceSingleton: Promisable<AccountBalanceServiceV2> | undefined
+
+export const initBalanceService: Initializable<BaseAccountBalanceServiceParams, AccountBalanceServiceV2>
+= async (params): Promise<AccountBalanceServiceV2> => {
+  if (balanceServiceSingleton) return balanceServiceSingleton
+  balanceServiceSingleton = await BaseAccountBalanceService.create(params)
+  return balanceServiceSingleton
+}

package/src/orchestration/services/implementation/chain/evm.ts

@@ -0,0 +1,38 @@
+import { assertEx } from '@xylabs/assert'
+import type { Address } from '@xylabs/hex'
+import { asAddress, ZERO_ADDRESS } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+import { isDefined } from '@xylabs/typeof'
+import type { BaseAccountableServiceParams } from '@xyo-network/chain-services'
+import { EvmChainService } from '@xyo-network/chain-services'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import type { ContractRunner } from 'ethers'
+import { Wallet } from 'ethers/wallet'
+
+import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
+
+let chainStakeServiceSingleton: Promisable<EvmChainService> | undefined
+
+export const canUseEvmContractChainService = (config: Config) => {
+  const { id } = config.chain
+  return isDefined(id) && id !== ZERO_ADDRESS && canUseEvmProvider({ config })
+}
+
+export const initEvmContractChainService: Initializable<BaseAccountableServiceParams, EvmChainService> = async ({
+  account, config, traceProvider, meterProvider, logger,
+}) => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
+  // Parse config
+  const emvStakingContractAddress = assertEx(config.chain.id, () => 'Error: config.chain.id is required')
+  // Configure ContractRunner
+  const id: Address = assertEx(asAddress(emvStakingContractAddress), () => 'Error: config.chain.id is not a valid address')
+  const provider = assertEx(await initEvmProvider({ config }))
+  const privateKey = assertEx(account.private?.hex, () => 'Error: Account does not have a private key')
+  const runner: ContractRunner = new Wallet(privateKey, provider)
+  // Create service
+  chainStakeServiceSingleton = EvmChainService.create({
+    id, runner, traceProvider, meterProvider, logger,
+  })
+  return await chainStakeServiceSingleton
+}

package/src/orchestration/services/implementation/chain/index.ts

@@ -0,0 +1,22 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BaseAccountableServiceParams } from '@xyo-network/chain-services'
+import { MemoryChainService } from '@xyo-network/chain-services'
+import type { ChainService, Initializable } from '@xyo-network/xl1-protocol'
+
+import { canUseEvmContractChainService, initEvmContractChainService } from './evm.ts'
+
+let chainStakeServiceSingleton: Promisable<ChainService> | undefined
+
+export const initChainService: Initializable<BaseAccountableServiceParams, ChainService> = ({ account, config }) => init({
+  config, name: 'ChainService', account,
+})
+
+const init: Initializable<BaseAccountableServiceParams, ChainService> = (params): Promisable<ChainService> => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
+  const { config } = params
+  chainStakeServiceSingleton = canUseEvmContractChainService(config)
+    ? initEvmContractChainService({ ...params, name: 'ChainStakeService' })
+    : MemoryChainService.create({ ...params, name: 'ChainStakeService' })
+  // Create service
+  return chainStakeServiceSingleton
+}

package/src/orchestration/services/implementation/evm/index.ts

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

package/src/orchestration/services/implementation/evm/initChainId.ts

@@ -0,0 +1,20 @@
+import { assertEx } from '@xylabs/assert'
+import { hexFrom, isHex } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+
+export const canUseChainId = (config: Config): boolean => {
+  return isDefined(config.evm.chainId)
+}
+
+export const getChainId = (config: Config) => {
+  const chainId = assertEx(config.evm.chainId, () => 'Missing config.evm.chainId')
+  if (isHex(chainId, { prefix: true })) {
+    const hex = hexFrom(chainId)
+    const parsed = Number.parseInt(hex, 16)
+    return parsed
+  } else {
+    const parsed = Number.parseInt(chainId, 10)
+    return parsed
+  }
+}

package/src/orchestration/services/implementation/evm/initEvmProvider.ts

@@ -0,0 +1,23 @@
+import { assertEx } from '@xylabs/assert'
+import type { Logger } from '@xylabs/logger'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import type { JsonRpcProvider } from 'ethers/providers'
+
+import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
+import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvider.ts'
+
+let provider: Promise<JsonRpcProvider> | undefined
+
+export const initEvmProvider = async ({ config }: { config: Config; logger?: Logger }) => {
+  if (provider) return provider
+  if (canUseInfuraProvider(config)) {
+    provider = initInfuraProvider(config)
+  } else if (canUseJsonRpcProvider(config)) {
+    provider = initJsonRpcProvider(config)
+  }
+  return assertEx(await provider, () => 'Error: No provider available')
+}
+
+export const canUseEvmProvider = ({ config }: { config: Config }) => {
+  return canUseInfuraProvider(config) || canUseJsonRpcProvider(config)
+}

package/src/orchestration/services/implementation/evm/initInfuraProvider.ts

@@ -0,0 +1,27 @@
+import { assertEx } from '@xylabs/assert'
+import { isDefined } from '@xylabs/typeof'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import { InfuraProvider } from 'ethers/providers'
+
+import { canUseChainId, getChainId } from './initChainId.ts'
+
+let instance: Promise<InfuraProvider> | undefined
+
+export const initInfuraProvider = (config: Config) => {
+  if (instance) return instance
+  const providerConfig = getInfuraProviderConfig(config)
+  instance = Promise.resolve(new InfuraProvider(...providerConfig))
+  return instance
+}
+
+export const canUseInfuraProvider = (config: Config): boolean => {
+  return canUseChainId(config)
+    && isDefined(config.evm?.infura?.projectId)
+    && isDefined(config.evm?.infura?.projectSecret)
+}
+
+export const getInfuraProviderConfig = (config: Config) => {
+  const projectId = assertEx(config.evm?.infura?.projectId, () => 'Missing config.evm.infura.projectId')
+  const projectSecret = assertEx(config.evm?.infura?.projectSecret, () => 'Missing config.evm.infura.projectSecret')
+  return [getChainId(config), projectId, projectSecret] as const
+}

package/src/orchestration/services/implementation/evm/initJsonRpcProvider.ts

@@ -0,0 +1,21 @@
+import { assertEx } from '@xylabs/assert'
+import { isDefined } from '@xylabs/typeof'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+import { JsonRpcProvider } from 'ethers/providers'
+
+import { canUseChainId, getChainId } from './initChainId.ts'
+
+export const initJsonRpcProvider = (config: Config) => {
+  const providerConfig = getJsonRpcProviderConfig(config)
+  return Promise.resolve(new JsonRpcProvider(...providerConfig))
+}
+
+export const canUseJsonRpcProvider = (config: Config) => {
+  return canUseChainId(config)
+    && isDefined(config.evm.jsonRpc?.url)
+}
+
+export const getJsonRpcProviderConfig = (config: Config) => {
+  const jsonRpcUrl = assertEx(config.evm.jsonRpc?.url, () => 'Missing config.evm.jsonRpc.url')
+  return [jsonRpcUrl, getChainId(config)] as const
+}

package/src/orchestration/services/implementation/head.ts

@@ -0,0 +1,44 @@
+import { delay } from '@xylabs/delay'
+import { ZERO_ADDRESS } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { createGenesisBlock, findMostRecentBlock } from '@xyo-network/chain-protocol'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { BlockBoundWitness, Initializable } from '@xyo-network/xl1-protocol'
+import { flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
+
+let headSingleton: Promisable<WithStorageMeta<BlockBoundWitness>> | undefined
+
+const createBootstrapHead = async (
+  chainSubmissionsArchivistWrite: ArchivistInstance,
+  chainArchivist: ArchivistInstance,
+  account: WalletInstance,
+): Promise<WithStorageMeta<BlockBoundWitness>> => {
+  const block = await createGenesisBlock(account, ZERO_ADDRESS, 10_000_000n, account.address)
+  const [bw] = block
+  await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(block))
+  // Wait for block to show up in finalized archivist
+  while (true) {
+    const result = await chainArchivist.get([bw._hash])
+    if (result.length > 0) break
+    await delay(1000) // Wait 1 second before retrying
+  }
+  return bw
+}
+
+export const initHead: Initializable<{
+  account: WalletInstance
+  chainArchivist: ArchivistInstance
+  chainSubmissionsArchivistWrite: ArchivistInstance
+}, WithStorageMeta<BlockBoundWitness>>
+ = async (params): Promise<WithStorageMeta<BlockBoundWitness>> => {
+   const {
+     account, chainArchivist, chainSubmissionsArchivistWrite,
+   } = params
+   if (headSingleton) return headSingleton
+   let head = await findMostRecentBlock(chainArchivist)
+   if (!head) head = await createBootstrapHead(chainSubmissionsArchivistWrite, chainArchivist, account)
+   headSingleton = head
+   return headSingleton
+ }

package/src/orchestration/services/implementation/index.ts

@@ -0,0 +1,10 @@
+export * from './account.ts'
+export * from './balance.ts'
+export * from './chain/index.ts'
+export * from './evm/index.ts'
+export * from './head.ts'
+export * from './iterator.ts'
+export * from './pendingTransactions.ts'
+export * from './producer.ts'
+export * from './reward.ts'
+export * from './validator.ts'

package/src/orchestration/services/implementation/iterator.ts

@@ -0,0 +1,36 @@
+import type {
+  BaseElectionServicesParams,
+  XyoChainIteratorParams,
+  XyoStakeIntentServiceParams,
+} from '@xyo-network/chain-services'
+import {
+  BaseElectionService, ChainBlockNumberIterationService,
+  XyoStakeIntentService,
+} from '@xyo-network/chain-services'
+import type {
+  ElectionService, EventingChainBlockNumberIterator, Initializable, StakeIntentService,
+} from '@xyo-network/xl1-protocol'
+
+let chainIteratorServiceSingleton: Promise<EventingChainBlockNumberIterator> | undefined
+let stakeIntentServiceSingleton: Promise<StakeIntentService> | undefined
+let electionServiceSingleton: Promise<ElectionService> | undefined
+
+export const initChainIterator: Initializable<XyoChainIteratorParams, EventingChainBlockNumberIterator> = (params) => {
+  if (chainIteratorServiceSingleton) return chainIteratorServiceSingleton
+  chainIteratorServiceSingleton = ChainBlockNumberIterationService.create(params)
+  return chainIteratorServiceSingleton
+}
+
+export const initStakeIntentService: Initializable<XyoStakeIntentServiceParams, StakeIntentService>
+= (params) => {
+  if (stakeIntentServiceSingleton) return stakeIntentServiceSingleton
+  stakeIntentServiceSingleton = XyoStakeIntentService.create(params)
+  return stakeIntentServiceSingleton
+}
+
+export const initElectionService: Initializable<BaseElectionServicesParams, ElectionService>
+= (params) => {
+  if (electionServiceSingleton) return electionServiceSingleton
+  electionServiceSingleton = BaseElectionService.create(params)
+  return electionServiceSingleton
+}

package/src/orchestration/services/implementation/pendingTransactions.ts

@@ -0,0 +1,14 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BasePendingTransactionsServiceParams } from '@xyo-network/chain-services'
+import { BasePendingTransactionsService } from '@xyo-network/chain-services'
+import type { Initializable, PendingTransactionsService } from '@xyo-network/xl1-protocol'
+
+let serviceSingleton: Promisable<PendingTransactionsService> | undefined
+
+export const initPendingTransactions: Initializable<BasePendingTransactionsServiceParams, PendingTransactionsService> = async (
+  params: BasePendingTransactionsServiceParams,
+): Promise<PendingTransactionsService> => {
+  if (serviceSingleton) return serviceSingleton
+  serviceSingleton = await BasePendingTransactionsService.create(params)
+  return serviceSingleton
+}

package/src/orchestration/services/implementation/producer.ts

@@ -0,0 +1,13 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BaseBlockProducerServiceParams } from '@xyo-network/chain-services'
+import { BaseBlockProducerService } from '@xyo-network/chain-services'
+import type { BlockProducerService, Initializable } from '@xyo-network/xl1-protocol'
+
+let serviceSingleton: Promisable<BlockProducerService> | undefined
+
+export const initBlockProducer: Initializable<BaseBlockProducerServiceParams, BlockProducerService>
+= async (params: BaseBlockProducerServiceParams): Promise<BlockProducerService> => {
+  if (serviceSingleton) return serviceSingleton
+  serviceSingleton = await BaseBlockProducerService.create(params)
+  return serviceSingleton
+}

package/src/orchestration/services/implementation/reward.ts

@@ -0,0 +1,41 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseBlockRewardServiceParams, EvmBlockRewardServiceParams } from '@xyo-network/chain-services'
+import { EvmBlockRewardService, MemoryBlockRewardService } from '@xyo-network/chain-services'
+import type { BlockRewardService, Initializable } from '@xyo-network/xl1-protocol'
+import type { Config } from '@xyo-network/xl1-protocol-sdk'
+
+import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
+
+let rewardServiceSingleton: Promise<BlockRewardService> | undefined
+
+export const initBlockRewardService: Initializable<
+  BaseBlockRewardServiceParams | EvmBlockRewardServiceParams,
+  BlockRewardService
+> = (params): Promise<BlockRewardService> => {
+  if (rewardServiceSingleton) return rewardServiceSingleton
+  const { config } = params
+  rewardServiceSingleton = canUseEvmBlockRewardService({ config })
+    ? initEvmBlockRewardService(params as EvmBlockRewardServiceParams)
+    : initXyoBlockRewardService(params)
+  return rewardServiceSingleton
+}
+
+const initXyoBlockRewardService = (params: BaseBlockRewardServiceParams): Promise<BlockRewardService> => {
+  if (rewardServiceSingleton) return rewardServiceSingleton
+  rewardServiceSingleton = MemoryBlockRewardService.create(params)
+  return rewardServiceSingleton
+}
+
+const canUseEvmBlockRewardService = (params: { config: Config }) => canUseEvmProvider({ config: params.config })
+
+const initEvmBlockRewardService = async (params: EvmBlockRewardServiceParams): Promise<BlockRewardService> => {
+  if (rewardServiceSingleton) return rewardServiceSingleton
+  const { account: paramsAccount } = params
+  const account = assertEx(paramsAccount, () => 'Error: Account is required')
+  const provider = assertEx(await initEvmProvider(params))
+  const evmBlockRewardServiceParams: EvmBlockRewardServiceParams = {
+    ...params, provider, account,
+  }
+  rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams)
+  return rewardServiceSingleton
+}

package/src/orchestration/services/implementation/validator.ts

@@ -0,0 +1,14 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BaseBlockProducerServiceParams } from '@xyo-network/chain-services'
+import type { BlockProducerService, Initializable } from '@xyo-network/xl1-protocol'
+
+import { initBlockProducer } from './producer.ts'
+
+let serviceSingleton: Promisable<BlockProducerService> | undefined
+
+export const initValidator: Initializable<BaseBlockProducerServiceParams, BlockProducerService>
+= (params: BaseBlockProducerServiceParams): Promisable<BlockProducerService> => {
+  if (serviceSingleton) return serviceSingleton
+  serviceSingleton = initBlockProducer(params)
+  return serviceSingleton
+}

package/src/orchestration/services/index.ts

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

package/src/orchestration/status/RuntimeStatusMonitor.ts

@@ -0,0 +1,117 @@
+import type { CreatableStatus } from '@xylabs/creatable'
+
+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: string): 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: string, 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/orchestration/status/ServiceStatus.ts

@@ -0,0 +1,21 @@
+import type {
+  CreatableName, CreatableStatus, CreatableStatusReporter,
+} from '@xylabs/creatable'
+import type { Logger } from '@xylabs/logger'
+
+export class LoggerStatusReporter implements CreatableStatusReporter {
+  protected logger: Logger
+
+  protected statusMap: Record<CreatableName, CreatableStatus> = {}
+
+  constructor(logger: Logger) {
+    this.logger = logger
+  }
+
+  report(name: string, 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/orchestration/status/index.ts

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

package/src/orchestration/store/StoreKind.ts

@@ -0,0 +1 @@
+export type StoreKind = 'lmdb'

package/src/orchestration/store/getStoreDirectory.ts

@@ -0,0 +1,14 @@
+import Path from 'node:path'
+
+import type { StoreKind } from './StoreKind.ts'
+
+/**
+ * Creates a convention-based directory path for an archivist store
+ * @param name The name of the archivist
+ * @param storageRoot The root directory for storage
+ * @param kind The kind of the archivist (optional)
+ * @returns The directory path for the archivist store
+ */
+export const getStoreDirectory = (name: string, storageRoot: string, kind?: StoreKind): string => {
+  return (kind === undefined) ? Path.join(storageRoot, name) : Path.join(storageRoot, kind, name)
+}

package/src/orchestration/store/index.ts

@@ -0,0 +1,2 @@
+export * from './getStoreDirectory.ts'
+export * from './StoreKind.ts'