@xyo-network/xl1-cli-lib 1.7.4

package/src/runCLI.ts

@@ -0,0 +1,111 @@
+import type { Logger } from '@xylabs/logger'
+import { isDefined } from '@xylabs/typeof'
+import { type Config, ConfigSchema } from '@xyo-network/xl1-protocol-sdk'
+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
+}

package/src/spec/BootstrapChain.spec.ts

@@ -0,0 +1,133 @@
+import '@xylabs/vitest-extended'
+
+import type { ChildProcess } from 'node:child_process'
+
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import type { Address } from '@xylabs/hex'
+import { asAddress, hexFromBigInt } from '@xylabs/hex'
+import {
+  approveTestStakeChainAddress,
+  createTestChainContract, createTestErc20, createTestGenesisBlock,
+  startGanache, stopGanache, transferTestTokens,
+} from '@xyo-network/chain-sdk'
+import { EvmChainService } from '@xyo-network/chain-services'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { ChainServiceCollectionV2 } from '@xyo-network/xl1-protocol-sdk'
+import { ConfigSchema, flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
+import type { ContractRunner } from 'ethers'
+import { getAddress } from 'ethers/address'
+import { JsonRpcProvider } from 'ethers/providers'
+import { parseUnits } from 'ethers/utils'
+import { Wallet } from 'ethers/wallet'
+import {
+  afterAll, beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { initServices } from '../orchestration/index.ts'
+
+const ganachePort = 8575
+const testPhrase = 'daring scout quote quarter avoid umbrella spin unhappy buddy luxury cannon urge culture emotion soldier'
+const sharedAccountPhrase = 'crane ribbon cook cousin tobacco vital moral protect merit knock veteran hint knee ocean nurse'
+const useGanache = false
+const bootstrapMultiProducer = false
+const multiProducerSeedPhrases: string[] = []
+
+describe.sequential.skip('MultiProducer Network', () => {
+  let ganacheProcess: ChildProcess
+  let blockProducerAccounts: WalletInstance[]
+  let erc20Address: Address
+  let xyoChainContractAddress: Address
+  // let chainArchivist: ArchivistInstance
+  // let head: BlockBoundWitness
+  // let chainIterator: ChainIterator
+  // let chainStakeService: EvmContractChainStake
+  // let stakeIntentService: StakeIntentService
+  let services: ChainServiceCollectionV2
+
+  const setupStakingContract = async () => {
+    const ganacheProcess = await startGanache(ganachePort, testPhrase)
+    const sharedAccount = await HDWallet.fromPhrase(sharedAccountPhrase, "m/44'/60'/0'/0")
+    const walletPerson = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/0'/0")
+    const account0 = await walletPerson.derivePath("m/44'/60'/0'/0/0")
+    const account1 = await walletPerson.derivePath("m/44'/60'/0'/0/1")
+    const erc20Address = await createTestErc20(ganachePort, testPhrase, account0)
+    await transferTestTokens(ganachePort, erc20Address, account0, account1)
+    const xyoChainContractAddress = await createTestChainContract(ganachePort, erc20Address, account0, sharedAccount)
+    await approveTestStakeChainAddress(ganachePort, erc20Address, xyoChainContractAddress, account0)
+    return [ganacheProcess, erc20Address, xyoChainContractAddress] as const
+  }
+
+  const fundAndStakeBlockProducerAccount = async (blockProducerAccount: WalletInstance) => {
+    const walletPerson = await HDWallet.fromPhrase(testPhrase, "m/44'/60'/0'/0")
+    const account0 = await walletPerson.derivePath("m/44'/60'/0'/0/0")
+    const provider0 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+    const ethWalletPerson0 = new Wallet(account0.privateKey, provider0)
+    await ethWalletPerson0.sendTransaction({ to: getAddress(blockProducerAccount.address), value: parseUnits('1', 18) })
+    await transferTestTokens(ganachePort, erc20Address, account0, blockProducerAccount)
+    await approveTestStakeChainAddress(ganachePort, erc20Address, xyoChainContractAddress, blockProducerAccount)
+    const provider1 = new JsonRpcProvider(`http://127.0.0.1:${ganachePort}`, 1337)
+    const ethWalletPerson1 = new Wallet(blockProducerAccount.privateKey, provider1)
+    const xyoChainPerson1 = await EvmChainService.create({ id: xyoChainContractAddress, runner: ethWalletPerson1 as ContractRunner })
+    expect(await xyoChainPerson1.addStake(await ethWalletPerson1.getAddress(), parseUnits('50', 18))).toBeTrue()
+  }
+
+  beforeAll(async () => {
+    if (useGanache) {
+      [ganacheProcess, erc20Address, xyoChainContractAddress] = await setupStakingContract()
+      assertEx(asAddress(xyoChainContractAddress), () => 'Invalid contract address')
+      for (const blockProducerAccount of blockProducerAccounts) {
+        await fundAndStakeBlockProducerAccount(blockProducerAccount)
+      }
+    } else if (bootstrapMultiProducer) {
+      services = await initServices({ config: ConfigSchema.parse({}), logger: console })
+      blockProducerAccounts = await Promise.all(multiProducerSeedPhrases.map(async (phrase) => {
+        return await HDWallet.fromPhrase(phrase, "m/44'/60'/0'/0")
+      }))
+    } else {
+      services = await initServices({ config: ConfigSchema.parse({}), logger: console })
+      const { account } = services
+      blockProducerAccounts = [account]
+    }
+
+    const {
+      chainArchivist, chainIterator, chainSubmissionsArchivistWrite,
+    } = services
+    if (chainIterator) {
+      const [
+        firstBlock,
+        signedPayloads,
+      ] = await createTestGenesisBlock(blockProducerAccounts)
+      const head = firstBlock
+      const firstBlockPayloads = flattenHydratedBlock([firstBlock, signedPayloads])
+      expect(head).toBeDefined()
+      expect(head.block).toBe(hexFromBigInt(0n))
+      // Insert all payloads from first block into chain archivist
+      await chainArchivist.insert(firstBlockPayloads)
+      await chainSubmissionsArchivistWrite.insert(firstBlockPayloads)
+      await chainIterator.updateHead(head)
+      // const pendingTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
+      // await pendingTransactionsArchivist.insert([firstBlock, ...signedStakedBlockProducerIntentsBws, ...signedStakedBlockProducerIntentsPayloads])
+    }
+  }, 120_000)
+
+  afterAll(async () => {
+    await delay(1000)
+    stopGanache(ganacheProcess)
+  }, 20_000)
+
+  it('producers show up as staked', async () => {
+    const { stakeIntentService } = services
+    await delay(1000)
+    const validStakedProducers = await stakeIntentService.getDeclaredCandidatesForBlock(0, 'producer')
+    expect(validStakedProducers).toBeArrayOfSize(blockProducerAccounts.length)
+    expect(validStakedProducers).toIncludeAllMembers(blockProducerAccounts.map(account => account.address))
+  })
+})
+
+describe('Stub', () => {
+  it('Stub', () => {
+    expect(true).toBeTrue()
+  })
+})