@xyo-network/xl1-cli 1.7.5 → 1.7.6

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

@@ -1,44 +0,0 @@
-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

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

@@ -1,36 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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 { 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
-  rewardServiceSingleton = canUseEvmBlockRewardService() ? 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 = () => canUseEvmProvider()
-
-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())
-  const evmBlockRewardServiceParams: EvmBlockRewardServiceParams = {
-    ...params, provider, account,
-  }
-  rewardServiceSingleton = EvmBlockRewardService.create(evmBlockRewardServiceParams)
-  return rewardServiceSingleton
-}

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

@@ -1,14 +0,0 @@
-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

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

package/src/orchestration/status/RuntimeStatusMonitor.ts

@@ -1,117 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

package/src/orchestration/store/StoreKind.ts

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

package/src/orchestration/store/getStoreDirectory.ts

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

package/src/orchestration/store/index.ts

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

package/src/runCLI.ts

@@ -1,111 +0,0 @@
-import type { Logger } from '@xylabs/logger'
-import { isDefined } from '@xylabs/typeof'
-import { type Config, ConfigSchema } from '@xyo-network/chain-protocol'
-import type { Argv } from 'yargs'
-import yargs from 'yargs'
-import { hideBin } from 'yargs/helpers'
-import { ZodError } from 'zod'
-
-import { runApi, runProducer } from './commands/index.ts'
-import { XL1LogoColorizedAscii } from './images.ts'
-import { initLogger } from './initLogger.ts'
-import { optionsFromZodSchema } from './optionsFromZodSchema.ts'
-import { Orchestrator } from './orchestration/index.ts'
-import { waitForHostPort } from './waitForHostPort.ts'
-
-/** Version string injected by Rollup at build time. */
-declare const __VERSION__: string
-
-interface RunCliContext {
-  logger: Logger
-  orchestrator: Orchestrator
-}
-
-/**
- * The configuration that will be used throughout the CLI.
- * This is materialized after parsing the command-line arguments,
- * environment variables, and defaults.
- */
-let config: Config
-
-const version = isDefined(__VERSION__) ? __VERSION__ : 'unknown'
-
-const getContextFromConfig = (config: Config): RunCliContext => {
-  const logger = initLogger(config)
-  const orchestrator = new Orchestrator(logger)
-  // Handle cancellation (Ctrl+C)
-  process.on('SIGINT', () => {
-    void (async () => {
-      try {
-        logger.log('\nSIGINT received. Attempting graceful shutdown...')
-        await orchestrator?.stop()
-        logger.log('Orchestrator stopped, exiting now.')
-        process.exit(0)
-      } catch (err) {
-        logger.error('Error stopping orchestrator:', err)
-        process.exit(1)
-      }
-    })()
-  })
-  return { logger, orchestrator }
-}
-
-// Main entry point
-export async function runCLI() {
-  // Parse command-line arguments using Yargs
-  const y = yargs(hideBin(process.argv)) as Argv<Config>
-  const argv = y
-    .usage(`
-🚀 XL1 Node CLI (${version})
-${XL1LogoColorizedAscii}
-Run various components of the XL1 ecosystem.
-
-Usage:
-$0 <command> [options]`)
-    .parserConfiguration({ 'dot-notation': true }) // foo.bar → { foo: { bar } }
-    .env('XL1')
-    .scriptName('xl1')
-    .config()
-    .version(version)
-    .middleware((argv) => {
-      try {
-        // Parse and validate the config
-        config = ConfigSchema.parse(argv)
-      } catch (err) {
-        if (err instanceof ZodError) {
-          for (const issue of err.errors) {
-            console.error(`${issue.path.join('.')} → ${issue.message}`)
-          }
-        }
-        throw new Error('Invalid configuration')
-      }
-    })
-    .options(optionsFromZodSchema(ConfigSchema.shape))
-  // .commandDir('./command/commands', opts) // Not yet supported for ESM
-    .wrap(y.terminalWidth())
-    .command('api', 'Run a XL1 API Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 API Node', () => {}, () => {
-          const context = getContextFromConfig(config)
-          runApi({ ...context, config })
-        })
-    })
-    .command('producer', 'Run a XL1 Producer Node', (yargs) => {
-      return yargs
-        .command('$0', 'Run a XL1 Producer Node', () => {}, async () => {
-          const context = getContextFromConfig(config)
-          await runProducer({ ...context, config })
-        })
-    })
-    .command('$0', 'Run a full XL1 Node', () => {}, async () => {
-      const context = getContextFromConfig(config)
-      runApi({ ...context, config })
-      await waitForHostPort('localhost', config.api.port)
-      await runProducer({ ...context, config })
-    })
-    .help()
-    .alias('help', 'h')
-    .argv
-
-  await argv
-}