@xyo-network/xl1-cli-lib 1.19.7 → 1.19.8

package/src/locatorFromConfig.ts

@@ -0,0 +1,197 @@
+import {
+  asAddress, assertEx, isString, type Logger,
+} from '@xylabs/sdk-js'
+import {
+  initApiWallet,
+  initBalanceSummaryMap,
+  initEvmProvidersIfAvailable, initFinalizationArchivistIfNeeded, initProducerAccount, initServerNode, initStatusReporter,
+  initTransferSummaryMap,
+} from '@xyo-network/chain-orchestration'
+import { SimpleBlockRunner } from '@xyo-network/chain-services'
+import { initTelemetry } from '@xyo-network/chain-telemetry'
+import { validateHydratedBlock, validateHydratedBlockState } from '@xyo-network/chain-validation'
+import type {
+  Config, CreatableProviderContext, ProviderFactoryLocatorInstance,
+} from '@xyo-network/xl1-sdk'
+import {
+  ProviderFactoryLocator, SimpleAccountBalanceViewer, SimpleBlockRewardViewer, SimpleBlockValidationViewer,
+  SimpleBlockViewer,
+  SimpleFinalizationViewer,
+  SimpleMempoolRunner,
+  SimpleMempoolViewer,
+  SimpleNetworkStakeViewer,
+  SimpleStepRewardsByPositionViewer,
+  SimpleStepRewardsByStakerViewer,
+  SimpleStepRewardsByStepViewer,
+  SimpleStepRewardsTotalViewer,
+  SimpleStepRewardsViewer,
+  SimpleStepViewer,
+  SimpleTimeSyncViewer,
+  SimpleWindowedBlockViewer,
+  SimpleXyoViewer,
+} from '@xyo-network/xl1-sdk'
+
+export async function telemetryContextFromConfig(config: Config, serviceName: string, serviceVersion: string) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {}
+  const { path: endpoint = '/metrics', port: port = 9466 } = config.telemetry?.metrics?.scrape ?? {}
+  return await initTelemetry({
+    attributes: {
+      serviceName,
+      serviceVersion,
+    },
+    otlpEndpoint,
+    metricsConfig: { endpoint, port },
+  })
+}
+
+export async function contextFromConfigWithoutLocator(
+  config: Config,
+  logger: Logger,
+  serviceName: string,
+  serviceVersion: string,
+): Promise<Omit<CreatableProviderContext, 'locator'>> {
+  const singletons = {}
+  const caches = {}
+  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion)
+  const statusReporter = initStatusReporter({ logger })
+  return {
+    ...telemetryConfig,
+    config,
+    singletons,
+    caches,
+    logger,
+    statusReporter,
+  }
+}
+
+export async function rootLocatorFromConfig(
+  config: Config,
+  context: Omit<CreatableProviderContext, 'locator'>,
+): Promise<ProviderFactoryLocatorInstance> {
+  let locator: ProviderFactoryLocatorInstance = new ProviderFactoryLocator(context)
+
+  locator.registerMany([
+    SimpleNetworkStakeViewer.factory<SimpleNetworkStakeViewer>(SimpleNetworkStakeViewer.dependencies, {}),
+    SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(SimpleTimeSyncViewer.dependencies, {}),
+    SimpleStepViewer.factory<SimpleStepViewer>(SimpleStepViewer.dependencies, {}),
+    SimpleStepRewardsViewer.factory<SimpleStepRewardsViewer>(SimpleStepRewardsViewer.dependencies, {}),
+    SimpleStepRewardsByPositionViewer.factory<SimpleStepRewardsByPositionViewer>(SimpleStepRewardsByPositionViewer.dependencies, {}),
+    SimpleStepRewardsByStakerViewer.factory<SimpleStepRewardsByStakerViewer>(SimpleStepRewardsByStakerViewer.dependencies, {}),
+    SimpleStepRewardsByStepViewer.factory<SimpleStepRewardsByStepViewer>(SimpleStepRewardsByStepViewer.dependencies, {}),
+    SimpleStepRewardsTotalViewer.factory<SimpleStepRewardsTotalViewer>(SimpleStepRewardsTotalViewer.dependencies, {}),
+    SimpleBlockValidationViewer.factory<SimpleBlockValidationViewer>(
+      SimpleBlockValidationViewer.dependencies,
+      { state: validateHydratedBlockState, protocol: validateHydratedBlock },
+    ),
+  ])
+  locator = await initEvmProvidersIfAvailable(locator)
+  locator = await (isString(config.remote.rpc?.url)
+    ? remoteLocatorFromConfig(config, { ...context, locator })
+    : localLocatorFromConfig(config, { ...context, locator }))
+  locator.freeze()
+  return locator
+}
+
+export async function localLocatorFromConfig(
+  config: Config,
+  context: CreatableProviderContext,
+): Promise<ProviderFactoryLocatorInstance> {
+  const balancesSummaryMap = assertEx(await initBalanceSummaryMap(context), () => 'Balance Summary Map not initialized')
+  const transfersSummaryMap = assertEx(await initTransferSummaryMap(context), () => 'Transfer Summary Map not initialized')
+
+  // TODO: this should not be an api wallet, but a server wallet
+  const wallet = await initApiWallet(context)
+
+  const {
+    writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist,
+  } = await initServerNode({
+    ...context,
+    wallet,
+    transfersSummaryMap,
+    balancesSummaryMap,
+  })
+
+  await initFinalizationArchivistIfNeeded(writableChainArchivist, config, wallet)
+
+  const locator = new ProviderFactoryLocator(context)
+  locator.registerMany([
+    SimpleMempoolViewer.factory<SimpleMempoolViewer>(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleMempoolRunner.factory<SimpleMempoolRunner>(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleAccountBalanceViewer.factory<SimpleAccountBalanceViewer>(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
+    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleBlockViewer.factory<SimpleBlockViewer>(SimpleBlockViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 10_000, syncInterval: 10_000 }),
+    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, {}),
+  ])
+  locator.freeze()
+  return locator
+}
+
+export async function remoteLocatorFromConfig(
+  config: Config,
+  context: CreatableProviderContext,
+): Promise<ProviderFactoryLocatorInstance> {
+  const balancesSummaryMap = assertEx(await initBalanceSummaryMap(context), () => 'Balance Summary Map not initialized')
+  const transfersSummaryMap = assertEx(await initTransferSummaryMap(context), () => 'Transfer Summary Map not initialized')
+
+  // TODO: this should not be an api wallet, but a server wallet
+  const wallet = await initApiWallet(context)
+
+  const {
+    readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist,
+  } = await initServerNode({
+    ...context,
+    wallet,
+    transfersSummaryMap,
+    balancesSummaryMap,
+  })
+
+  const locator = new ProviderFactoryLocator(context)
+  locator.registerMany([
+    SimpleMempoolViewer.factory<SimpleMempoolViewer>(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleMempoolRunner.factory<SimpleMempoolRunner>(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleAccountBalanceViewer.factory<SimpleAccountBalanceViewer>(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
+    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleBlockViewer.factory<SimpleBlockViewer>(SimpleBlockViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 10_000, syncInterval: 10_000 }),
+    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, {}),
+  ])
+  locator.freeze()
+  return locator
+}
+
+export async function producerLocatorFromConfig(
+  config: Config,
+  context: CreatableProviderContext,
+): Promise<ProviderFactoryLocatorInstance> {
+  const { logger } = context
+  const account = await initProducerAccount({ config })
+  const locator = new ProviderFactoryLocator(context)
+  const rewardAddress = asAddress(config.actors.producer.rewardAddress ?? account.address, true)
+  logger?.info(`Using reward address ${rewardAddress}`)
+  if (rewardAddress === account.address) {
+    logger?.warn(`Using producer account address as reward address: ${account.address}`)
+  }
+
+  locator.registerMany([
+    SimpleBlockRewardViewer.factory<SimpleBlockRewardViewer>(SimpleBlockRewardViewer.dependencies, {}),
+    SimpleBlockRunner.factory<SimpleBlockRunner>(
+      SimpleBlockRunner.dependencies,
+      { account, rewardAddress },
+    )])
+  locator.freeze()
+  return locator
+}
+
+export async function locatorsFromConfig(
+  actors: string[],
+  config: Config,
+  context: Omit<CreatableProviderContext, 'locator'>,
+): Promise<Record<string, ProviderFactoryLocatorInstance>> {
+  const result: Record<string, ProviderFactoryLocatorInstance> = { _root: await rootLocatorFromConfig(config, context) }
+  const producer = actors.includes('producer') ? await producerLocatorFromConfig(config, result._root.context) : undefined
+  if (producer) {
+    result.producer = producer
+  }
+  return result
+}

package/src/runCLI.ts

@@ -1,11 +1,12 @@
 import type { Logger } from '@xylabs/sdk-js'
-import { isDefined, toAddress } from '@xylabs/sdk-js'
+import {
+  deepMerge, isDefined, toAddress,
+} from '@xylabs/sdk-js'
 import { runApi } from '@xyo-network/chain-api'
 import { Orchestrator } from '@xyo-network/chain-orchestration'
 import { runProducer } from '@xyo-network/chain-producer'
-import type { Config } from '@xyo-network/xl1-sdk'
+import type { ActorName, Config } from '@xyo-network/xl1-sdk'
 import { ConfigZod, isZodError } from '@xyo-network/xl1-sdk'
-import { merge as deepMerge } from 'ts-deepmerge'
 import type { Argv } from 'yargs'
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
@@ -15,18 +16,19 @@ import {
 } from './commands/index.ts'
 import { XL1LogoColorizedAscii } from './images.ts'
 import { initLogger } from './initLogger.ts'
+import { contextFromConfigWithoutLocator, locatorsFromConfig } from './locatorFromConfig.ts'
 import { optionsFromGlobalZodRegistry } from './optionsFromGlobalZodRegistry.ts'
 import { tryParseConfig } from './tryParseConfig.ts'
 import { waitForHostPort } from './waitForHostPort.ts'
 
-/** Version string injected by Rollup at build time. */
-declare const __VERSION__: string
-
 interface RunCliContext {
   logger: Logger
   orchestrator: Orchestrator
 }
 
+/** Version string injected by Rollup at build time. */
+declare const __VERSION__: string
+
 /**
  * The configuration that will be used throughout the CLI.
  * This is materialized after parsing the command-line arguments,
@@ -67,6 +69,28 @@ const getContextFromConfig = async (configuration: Config): Promise<RunCliContex
   return { logger, orchestrator }
 }
 
+const getLocatorsFromConfig = async (actors: string[], configuration: Config) => {
+  const logger = initLogger(configuration)
+  const orchestrator = await Orchestrator.create({ logger })
+  const context = await contextFromConfigWithoutLocator(configuration, logger, 'xl1-cli', version)
+  const locators = await locatorsFromConfig(actors, configuration, context)
+  // 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 { locators, orchestrator }
+}
+
 // Main entry point
 export async function runCLI() {
   // Parse command-line arguments using Yargs
@@ -114,6 +138,24 @@ $0 <command> [options]`)
           throw validatedConfigResult.error
         }
         configuration = validatedConfigResult.data
+
+        const { actors, ...rootConfig } = configuration
+        const actorNames = Object.keys(actors) as ActorName[]
+
+        for (const actorName of actorNames) {
+          configuration.actors[actorName] = deepMerge(
+            rootConfig ?? {},
+            configuration.actors[actorName] ?? {},
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ) as any
+        }
+
+        // Check if user wants to dump config and exit
+        if (argv['dump-config']) {
+          console.log(JSON.stringify(configuration, null, 2))
+          // eslint-disable-next-line unicorn/no-process-exit
+          process.exit(0)
+        }
       } catch (err) {
         if (isZodError(err)) {
           console.error(`Zod error: ${err.message}`)
@@ -153,10 +195,8 @@ $0 <command> [options]`)
     .command('producer', 'Run a XL1 Producer Node', (yargs) => {
       return yargs
         .command('$0', 'Run a XL1 Producer Node', () => {}, async () => {
-          const context = await getContextFromConfig(configuration)
-          await runProducer({
-            ...context, config: configuration, singletons: {},
-          })
+          const { locators, orchestrator } = await getLocatorsFromConfig(['producer'], configuration)
+          await runProducer(configuration, orchestrator, locators['producer'])
         })
     })
     .command('reward-redemption-api', 'Run a XL1 Rewards Redemption API Node', (yargs) => {
@@ -167,23 +207,33 @@ $0 <command> [options]`)
         })
     })
     .command('$0', 'Run a full XL1 Node', () => {}, async () => {
+      const actors = ['producer', 'api']
+      if (configuration.actors.mempool.enabled) {
+        actors.push('mempool')
+      }
       const context = await getContextFromConfig(configuration)
-      if (configuration.mempool.enabled) {
+      const { locators, orchestrator } = await getLocatorsFromConfig(['producer'], configuration)
+      if (configuration.actors.mempool.enabled) {
         // Start Mempool but do not block
         runMempool({ ...context, config: configuration })
         // Wait for Mempool to be ready
-        await waitForHostPort(configuration.mempool.host, configuration.mempool.port)
+        await waitForHostPort(configuration.actors.mempool.host, configuration.actors.mempool.port)
       }
       // Start API but do not block
       await runApi({
         ...context, config: configuration, singletons: {},
       })
       // Wait for API to be ready
-      await waitForHostPort(configuration.api.host, configuration.api.port)
+      await waitForHostPort(configuration.actors.api.host, configuration.actors.api.port)
       // Start Producer and block on it
-      await runProducer({
-        ...context, config: configuration, singletons: {},
-      })
+      await runProducer(configuration, orchestrator, locators['producer'])
+    })
+    .options({
+      'dump-config': {
+        type: 'boolean',
+        description: 'Just process the configuration and print the resolved config to stdout, then exit.',
+        default: false,
+      },
     })
     .help()
     .alias('help', 'h')