@xyo-network/xl1-cli 1.6.2

package/nodemon.json

@@ -0,0 +1,9 @@
+{
+  "env": {
+    "NODE_ENV": "development"
+  },
+  "exec": "node -r dotenv/config --max-old-space-size=8192 ./dist/node/index.mjs",
+  "ext": "ts,js,json",
+  "ignore": ["dist", "node_modules", "**/*.spec.ts"],
+  "watch": ["src"]
+}

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@xyo-network/xl1-cli",
+  "version": "1.6.2",
+  "description": "XYO Layer One API",
+  "homepage": "https://xylabs.com",
+  "bugs": {
+    "url": "git+https://github.com/xylabs/xyo-chain/issues",
+    "email": "support@xylabs.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xylabs/xyo-chain.git"
+  },
+  "license": "LGPL-3.0-only",
+  "author": {
+    "name": "XY Labs Development Team",
+    "email": "support@xylabs.com",
+    "url": "https://xylabs.com"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/node/index.mjs"
+    },
+    "./package.json": "./package.json",
+    "./README.md": "./README.md"
+  },
+  "module": "build/node/index.mjs",
+  "types": "build/index.d.ts",
+  "bin": {
+    "xl1": "./scripts/xl1.mjs"
+  },
+  "scripts": {
+    "build-tests": "tsc --noEmit --lib dom,esnext",
+    "bundle-cli": "rollup -c rollup.config.mjs",
+    "package-clean": "rimraf dist build",
+    "package-compile": "yarn package-compile-only && yarn package-compile-bundles",
+    "package-compile-bundles": "yarn bundle-cli"
+  },
+  "dependencies": {
+    "lmdb": "^3.4.1"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@xylabs/array": "^4.12.44",
+    "@xylabs/assert": "^4.12.44",
+    "@xylabs/base": "^4.12.44",
+    "@xylabs/creatable": "^4.12.44",
+    "@xylabs/delay": "^4.12.44",
+    "@xylabs/events": "^4.12.44",
+    "@xylabs/forget": "^4.12.44",
+    "@xylabs/hex": "^4.12.44",
+    "@xylabs/logger": "^4.12.44",
+    "@xylabs/promise": "^4.12.44",
+    "@xylabs/telemetry": "^4.12.44",
+    "@xylabs/ts-scripts-yarn3": "^6.5.18",
+    "@xylabs/tsconfig": "^6.5.18",
+    "@xylabs/typeof": "^4.12.44",
+    "@xylabs/vitest-extended": "^4.12.44",
+    "@xyo-network/archivist-lmdb": "^4.0.2",
+    "@xyo-network/archivist-memory": "^4.0.2",
+    "@xyo-network/archivist-model": "^4.0.2",
+    "@xyo-network/chain-api": "^1.6.2",
+    "@xyo-network/chain-modules": "^1.6.2",
+    "@xyo-network/chain-orchestration": "^1.6.2",
+    "@xyo-network/chain-protocol": "^1.6.2",
+    "@xyo-network/chain-sdk": "^1.6.2",
+    "@xyo-network/chain-services": "^1.6.2",
+    "@xyo-network/chain-telemetry": "^1.6.2",
+    "@xyo-network/chain-utils": "^1.6.2",
+    "@xyo-network/chain-validation": "^1.6.2",
+    "@xyo-network/payload-builder": "^4.0.2",
+    "@xyo-network/payload-model": "^4.0.2",
+    "@xyo-network/wallet": "^4.0.2",
+    "@xyo-network/wallet-model": "^4.0.2",
+    "@xyo-network/xl1-protocol": "^1.6.1",
+    "@xyo-network/xl1-protocol-sdk": "^1.6.2",
+    "async-mutex": "^0.5.0",
+    "dotenv": "^17.2.0",
+    "ethers": "^6.15.0",
+    "nodemon": "^3.1.10",
+    "rollup": "^4.44.2",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "vitest-mock-extended": "^3.1.0",
+    "yargs": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=22.3 <23"
+  },
+  "engineStrict": true,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/rollup.config.mjs

@@ -0,0 +1,73 @@
+import resolve from '@rollup/plugin-node-resolve'
+import typescript from '@rollup/plugin-typescript'
+import commonjs from '@rollup/plugin-commonjs'
+import replace from '@rollup/plugin-replace'
+import json from '@rollup/plugin-json'
+
+import terser from '@rollup/plugin-terser'
+
+import { fileURLToPath } from 'node:url'
+import PATH from 'node:path'
+import { builtinModules } from 'node:module'
+
+const __dirnameReplacement = JSON.stringify(PATH.dirname(fileURLToPath(import.meta.url)))
+
+const externalModules = new Set([
+  'lmdb',
+])
+
+export default {
+  input: './src/xl1.ts',
+  output: [
+    {
+      file: 'dist/cli-min.mjs',
+      format: 'esm',
+      inlineDynamicImports: true,
+      sourcemap: false,
+    },
+  ],
+  external: (id) => {
+    // Externalize all modules EXCEPT those starting with "my-lib-"
+    if (id.startsWith('@xylabs/')) {
+      return false // bundle it
+    }
+    if (id.startsWith('@xyo-network/')) {
+      return false // bundle it
+    }
+    if (id.startsWith('.')) {
+      return false // bundle it
+    }
+    if (id.startsWith('/')) {
+      return false // bundle it
+    }
+    if (builtinModules.includes(id)) {
+      return true // don't bundle it
+    }
+    if (id.startsWith('node:')) {
+      return true // don't bundle it
+    }
+    if (externalModules.has(id)) {
+      console.log(`Externalizing: ${id}`)
+      return true // don't bundle it
+    }
+    return false // bundle it
+  },
+  plugins: [
+    json(),
+    commonjs(),
+    resolve({
+      exportConditions: ['node'],
+      preferBuiltins: true,
+    }),
+    typescript(
+      {
+        outDir: './dist', declaration: false, declarationMap: false,
+      },
+    ),
+    replace({
+      preventAssignment: true,
+      values: { __dirname: __dirnameReplacement },
+    }),
+    terser(),
+  ],
+}

package/scripts/xl1.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/cli-min.mjs'

package/src/commands/api/index.ts

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

package/src/commands/api/runApi.ts

@@ -0,0 +1,7 @@
+import { getServer } from '@xyo-network/chain-api'
+import { config } from 'dotenv'
+
+export function runApi() {
+  config()
+  void getServer()
+}

package/src/commands/index.ts

@@ -0,0 +1,3 @@
+export * from './api/index.ts'
+export * from './producer/index.ts'
+export * from './validator/index.ts'

package/src/commands/producer/createDeclaration.ts

@@ -0,0 +1,17 @@
+import { createProducerChainStakeIntentTransaction } from '@xyo-network/chain-protocol'
+import { XYO_ZERO_ADDRESS } from '@xyo-network/chain-utils'
+
+import { initAccount } from '../../orchestration/index.ts'
+
+export const createProducerDeclaration = async (): Promise<void> => {
+  const producerAccount = await initAccount()
+  const [tx, payloads] = await createProducerChainStakeIntentTransaction(
+    XYO_ZERO_ADDRESS,
+    [producerAccount],
+    producerAccount.address,
+    2_000_000_000,
+    0,
+  )
+  const intent = [tx, payloads]
+  console.log(JSON.stringify(intent, null, 2))
+}

package/src/commands/producer/index.ts

@@ -0,0 +1,2 @@
+export * from './createDeclaration.ts'
+export * from './runProducer.ts'

package/src/commands/producer/runProducer.ts

@@ -0,0 +1,25 @@
+import type { Orchestrator } from '../../orchestration/index.ts'
+import {
+  BalanceActor, ChainHeadUpdateActor, initServices, ProducerActor,
+} from '../../orchestration/index.ts'
+
+export const runProducer = async (orchestrator: Orchestrator) => {
+  // Initialize services
+  console.log('Services: Initializing...')
+  const services = await initServices()
+  console.log('Services: Initialized')
+
+  // Create actors
+  const chainHeadUpdate = await ChainHeadUpdateActor.create(services)
+  const producer = await ProducerActor.create(services)
+  const balances = await BalanceActor.create(services)
+  const actors = [chainHeadUpdate, producer, balances]
+  // const actors = [chainHeadUpdate, producer]
+
+  for (const actor of actors) {
+  // Register the actor with the orchestrator
+    await orchestrator.registerActor(actor)
+  }
+  // Start the orchestrator => automatically activates the actor
+  await orchestrator.start()
+}

package/src/commands/validator/index.ts

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

package/src/commands/validator/runValidator.ts

@@ -0,0 +1,13 @@
+import type { Orchestrator } from '../../orchestration/index.ts'
+import { Actor } from '../../orchestration/index.ts'
+
+export const runValidator = async (orchestrator: Orchestrator) => {
+  // Create a single actor
+  const myActor = new Actor('Validator', 'Validator', {})
+
+  // Register the actor with the orchestrator
+  await orchestrator.registerActor(myActor)
+
+  // Start the orchestrator => automatically activates the actor
+  await orchestrator.start()
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './orchestration/index.ts'
+export * from './runCLI.ts'
+export * from './start.ts'

package/src/initEnv.ts

@@ -0,0 +1,8 @@
+import dotenv from 'dotenv'
+
+export const initEnv = () => {
+  dotenv.config()
+  if (process.env.ENV_FILE !== undefined) {
+    dotenv.config({ path: process.env.ENV_FILE, override: true })
+  }
+}

package/src/orchestration/actor/implementation/BalanceActor.ts

@@ -0,0 +1,51 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseParams } from '@xylabs/base'
+import type { Promisable } from '@xylabs/promise'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { OpenTelemetryProviders } from '@xyo-network/xl1-protocol'
+import type { ChainServiceCollectionV2 } from '@xyo-network/xl1-protocol-sdk'
+import { Mutex } from 'async-mutex'
+
+import { Actor } from '../model/index.ts'
+
+export type BalanceActorParams = BaseParams<
+  Pick<ChainServiceCollectionV2, 'balanceService' | 'chainIterator'>
+  & OpenTelemetryProviders>
+
+export class BalanceActor extends Actor<BalanceActorParams> {
+  protected _updateMutex = new Mutex()
+
+  protected constructor(params: BalanceActorParams) {
+    super('BalanceActor', 'Balance', params)
+  }
+
+  protected get balanceService() {
+    return assertEx(this.params.balanceService, () => 'balanceService not set')
+  }
+
+  protected get chainIterator() {
+    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
+  }
+
+  static create(params: BalanceActorParams): Promisable<BalanceActor> {
+    return new BalanceActor(params)
+  }
+
+  override async start(): Promise<void> {
+    await super.start()
+    this.chainIterator.on('headUpdate', async () => {
+      await this.updateBalance()
+    })
+    this.registerTimer('BalanceTimer', async () => {
+      await this.updateBalance()
+    }, 1000, 1000)
+  }
+
+  protected async updateBalance(): Promise<void> {
+    if (this._updateMutex.isLocked()) return
+    await this._updateMutex.runExclusive(async () => {
+      const head = await PayloadBuilder.hash(await this.chainIterator.head())
+      await this.balanceService.balances(head, [])
+    })
+  }
+}

package/src/orchestration/actor/implementation/ChainHeadUpdateActor.ts

@@ -0,0 +1,65 @@
+import { filterAs } from '@xylabs/array'
+import { assertEx } from '@xylabs/assert'
+import type { BaseParams } from '@xylabs/base'
+import { toHex } from '@xylabs/hex'
+import { findMostRecentBlock, sortBlocks } from '@xyo-network/chain-protocol'
+import type { Payload } from '@xyo-network/payload-model'
+import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
+import { asBlockBoundWitness } from '@xyo-network/xl1-protocol'
+import type { ChainServiceCollection } from '@xyo-network/xl1-protocol-sdk'
+
+import { Actor } from '../model/index.ts'
+
+export type ChainHeadUpdateActorParams = BaseParams<Pick<ChainServiceCollection, 'chainIterator' | 'chainArchivist'>>
+
+export class ChainHeadUpdateActor extends Actor<ChainHeadUpdateActorParams> {
+  protected constructor(params: ChainHeadUpdateActorParams) {
+    super('ChainHeadUpdate', 'ChainHeadUpdate', params)
+  }
+
+  protected get chainFinalizedArchivist() {
+    return assertEx(this.params.chainArchivist, () => 'ChainArchivist not set')
+  }
+
+  protected get chainIterator() {
+    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
+  }
+
+  static async create(params: ChainHeadUpdateActorParams): Promise<ChainHeadUpdateActor> {
+    await Promise.resolve()
+    return new ChainHeadUpdateActor(params)
+  }
+
+  override async start(): Promise<void> {
+    await super.start()
+    // Register event handler on all insert event to check for new head
+    this.chainFinalizedArchivist.on('inserted', async (data: { payloads: Payload[] }) => {
+      await this.checkInsertedForNewHead(data)
+    })
+    // Poll in case we missed an event
+    this.registerTimer('ChainHeadUpdateTimer', async () => await this.pollForNewHead(), 0, 250)
+  }
+
+  private async checkInsertedForNewHead(data: { payloads: Payload[] }) {
+    const candidateBlock = sortBlocks(filterAs(data.payloads, asBlockBoundWitness)).at(-1)
+    await this.updateHeadIfNewer(candidateBlock)
+  }
+
+  private async pollForNewHead() {
+    const candidateBlock = await findMostRecentBlock(this.chainFinalizedArchivist)
+    await this.updateHeadIfNewer(candidateBlock)
+  }
+
+  private async updateHeadIfNewer(candidateBlock?: BlockBoundWitness) {
+    if (!candidateBlock) return
+    const currentHead = await this.chainIterator.head()
+    const candidateBlockNumber = candidateBlock.block
+    const candidateBlockNumberDisplay = `0x${toHex(candidateBlockNumber)}`
+    const currentBlockNumber = currentHead?.block ?? -1
+    if (candidateBlockNumber > currentBlockNumber) {
+      this.logger?.log('Found more recent head:', candidateBlockNumberDisplay)
+      await this.chainIterator.updateHead(candidateBlock)
+      this.logger?.log('Updated head:', candidateBlockNumberDisplay)
+    }
+  }
+}

package/src/orchestration/actor/implementation/ProducerActor.ts

@@ -0,0 +1,250 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseParams } from '@xylabs/base'
+import { toHex } from '@xylabs/hex'
+import { isDefined, isUndefined } from '@xylabs/typeof'
+import { createDeclarationIntent } from '@xyo-network/chain-protocol'
+import { BaseBlockProducerService } from '@xyo-network/chain-services'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { PayloadBundle } from '@xyo-network/payload-model'
+import { PayloadBundleSchema } from '@xyo-network/payload-model'
+import type {
+  ChainStakeIntent,
+  HydratedBlock, OpenTelemetryProviders,
+} from '@xyo-network/xl1-protocol'
+import type { ChainServiceCollectionV2 } from '@xyo-network/xl1-protocol-sdk'
+import {
+  buildTransaction, flattenHydratedBlock, flattenHydratedTransaction,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import { Actor } from '../model/index.ts'
+
+export type ProducerActorParams = BaseParams<
+  Pick<ChainServiceCollectionV2,
+  'account'
+  | 'balanceService'
+  | 'chainIterator'
+  | 'chainStakeViewer'
+  | 'chainSubmissionsArchivistWrite'
+  | 'pendingBundledTransactionsArchivistWrite'
+  | 'producer'
+  | 'stakeIntentService'
+  >
+  & OpenTelemetryProviders>
+
+const SHOULD_REGISTER_REDECLARATION_INTENT_TIMER = true
+const TEN_MINUTES = 10 * 60 * 1000 // 10 minutes in milliseconds
+
+export class ProducerActor extends Actor<ProducerActorParams> {
+  protected _lastProducedBlock: HydratedBlock | undefined
+  protected _lastRedeclarationIntent: ChainStakeIntent | undefined
+
+  protected constructor(params: ProducerActorParams) {
+    super(assertEx(params.producer?.address, () => 'Missing producer in params'), 'Producer', params)
+  }
+
+  protected get account() {
+    return assertEx(this.params.account, () => 'account not set')
+  }
+
+  protected get balanceService() {
+    return assertEx(this.params.balanceService, () => 'balanceService not set')
+  }
+
+  protected get chainIterator() {
+    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
+  }
+
+  protected get chainStakeViewer() {
+    return assertEx(this.params.chainStakeViewer, () => 'chainStakeViewer not set')
+  }
+
+  protected get chainSubmissionsArchivistWrite() {
+    return assertEx(this.params.chainSubmissionsArchivistWrite, () => 'chainSubmissionsArchivistWrite not set')
+  }
+
+  protected get pendingBundledTransactionsArchivistWrite() {
+    return assertEx(this.params.pendingBundledTransactionsArchivistWrite, () => 'pendingBundledTransactionsArchivistWrite not set')
+  }
+
+  protected get producer() {
+    return assertEx(this.params.producer, () => 'producer not set')
+  }
+
+  protected get stakeIntentService() {
+    return assertEx(this.params.stakeIntentService, () => 'stakeIntentService not set')
+  }
+
+  static async create(params: ProducerActorParams): Promise<ProducerActor> {
+    await Promise.resolve()
+    return new ProducerActor(params)
+  }
+
+  override async start(): Promise<void> {
+    await super.start()
+    // Register a timer to check if we should produce a block
+    this.registerTimer('BlockProductionTimer', async () => {
+      await this.spanAsync('produceBlock', async () => {
+        // Get the updated head
+        const head = await this.chainIterator.head()
+        // Check if we've already produced the next block for this head
+        const headHash = await PayloadBuilder.hash(head)
+        // If our last produced block was the next block for the current head, we do not
+        // need to produce another. This prevents duplicate blocks from being produced
+        if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
+          this.logger?.log('Block already produced:', `0x${toHex(this._lastProducedBlock[0].block)}`)
+        } else {
+          // Produce the next block
+          const nextBlock = await this.producer.next(head)
+          // If it was produced
+          if (nextBlock) {
+            const displayBlockNumber = `0x${toHex(nextBlock[0].block)}`
+            this.logger?.log('Produced block:', displayBlockNumber)
+            // Insert the block into the chain
+            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock))
+            this.logger?.log('Published block:', displayBlockNumber)
+            // Record that we have produced a block so we do not produce it again
+            this._lastProducedBlock = nextBlock
+          }
+        }
+      })
+    }, 100, 500)
+
+    if (SHOULD_REGISTER_REDECLARATION_INTENT_TIMER) {
+      // Register a timer to check if we should redeclare the producer
+      this.registerTimer('ProducerRedeclarationTimer', async () => {
+        await this.spanAsync('producerRedeclarationTimer', async () => {
+          // Decide if we should redeclare intent
+          if (!BaseBlockProducerService.RedeclareIntent) return
+
+          // Get the current block
+          const head = await this.chainIterator.head()
+          if (isUndefined(head)) return
+          const currentBlock = head.block
+
+          // Calculate the time until the producer's declaration expires
+          const blocksUntilExpiration = await this.calculateBlocksUntilProducerDeclarationExpiration(currentBlock)
+
+          // Allow the producer time to redeclare itself via block production
+          // (for free) before submitting a redeclaration intent transaction.
+          if (blocksUntilExpiration > BaseBlockProducerService.RedeclarationWindow * 0.1) {
+            // Clear any previous redeclaration intent
+            this._lastRedeclarationIntent = undefined
+            // No need to redeclare yet
+            return
+          }
+
+          // If we already have a valid redeclaration intent, do not create another
+          // unless it has expired.
+          if (this._lastRedeclarationIntent) {
+            // Check if the last redeclaration intent is still valid
+            if (this._lastRedeclarationIntent.exp > currentBlock) return
+            // If it has expired, clear the last redeclaration intent
+            this._lastRedeclarationIntent = undefined
+          }
+
+          // Check if we have a valid balance before declaring intent
+          if (!await this.validateCurrentBalance()) {
+            this.logger?.error(
+              `Add balance to address ${this.account.address} for the producer to declare it's intent.`,
+            )
+            return
+          }
+
+          // Check if we have a valid stake before declaring intent
+          if (!(await this.validateCurrentStake())) {
+            this.logger?.error(
+              `Add stake to contract address ${process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS}`
+              + ' for the producer to declare it\'s intent.',
+            )
+            return
+          }
+
+          // Create a redeclaration intent
+          this.logger?.log('Creating redeclaration intent for producer:', this.account.address)
+          const redeclarationIntent = createDeclarationIntent(
+            this.account.address,
+            'producer',
+            currentBlock,
+            currentBlock + BaseBlockProducerService.RedeclarationDuration,
+          )
+
+          // Submit the redeclaration intent
+          await this.submitRedeclarationIntent(currentBlock, redeclarationIntent)
+
+          // On successful submission, save the redeclaration intent
+          this._lastRedeclarationIntent = redeclarationIntent
+        })
+      }, 10_000, TEN_MINUTES)
+    }
+  }
+
+  protected async calculateBlocksUntilProducerDeclarationExpiration(currentBlock: number): Promise<number> {
+    // Decide if we need to redeclare intent
+    const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.account.address, 'producer')
+    // TODO: This doesn't handle the case where the producer had declared a range for the future
+    // but we're in a range that's not the future
+    // Sort in ascending order based on ending range to get range with highest ending block
+    const lastRange = ranges.toSorted((a, b) => a[1] > b[1] ? 1 : -1).at(-1)
+
+    // Use the most recent range's end block as the current declaration end OR
+    const [, currentDeclarationEnd] = lastRange
+    // If we have no ranges, we need to declare intent, so use the current block
+      || [undefined, currentBlock]
+
+    // Calculate the time until the producer's declaration expires
+    const timeToProducerExpiration = currentDeclarationEnd - currentBlock
+    return timeToProducerExpiration
+  }
+
+  protected async submitRedeclarationIntent(currentBlock: number, redeclarationIntent: ChainStakeIntent): Promise<void> {
+    this.logger?.log('Submitting redeclaration intent for producer:', this.account.address)
+    // Create a transaction to submit the redeclaration intent
+    const tx = await buildTransaction(
+      this.chainIterator.chainId,
+      [redeclarationIntent],
+      [],
+      this.account,
+      currentBlock,
+      currentBlock + 1000,
+    )
+    const payloads = flattenHydratedTransaction(tx)
+    const root = tx[0]._hash
+    const payloadBundle = new PayloadBuilder<PayloadBundle>({ schema: PayloadBundleSchema }).fields({ payloads, root }).build()
+
+    // Submit the redeclaration intent
+    await this.pendingBundledTransactionsArchivistWrite.insert([payloadBundle])
+
+    this.logger?.log('Submitted redeclaration intent for producer:', this.account.address)
+  }
+
+  protected async validateCurrentBalance(): Promise<boolean> {
+    // Check if we have a valid balance before declaring intent
+    const head = this._lastProducedBlock?.[0]._hash
+    if (isDefined(head)) {
+      const balances = await this.balanceService.balances(head, [this.account.address])
+      const currentBalance = balances[this.account.address] ?? 0n
+      if (currentBalance <= 0n) {
+        this.logger?.error(`Producer ${this.account.address} has no balance.`)
+        return false
+      }
+      return true
+    }
+    return true
+  }
+
+  protected async validateCurrentStake(): Promise<boolean> {
+    // TODO: Use StakeIntentService to get the required minimum stake for
+    // the intent once services is published
+    // const requiredMinimumStake = this.stakeIntentService.getRequiredMinimumStakeForIntent('producer')
+    const requiredMinimumStake = isDefined(process.env.XYO_PRODUCER_MIN_STAKE)
+      ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE)
+      : 1n
+    // Check if we have a valid stake before declaring intent
+    const currentStake = await this.chainStakeViewer.activeByAddressStaked(this.account.address)
+    if (currentStake < requiredMinimumStake) {
+      this.logger?.error(`Producer ${this.account.address} has insufficient stake.`)
+      return false
+    }
+    return true
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './BalanceActor.ts'
+export * from './ChainHeadUpdateActor.ts'
+export * from './ProducerActor.ts'

package/src/orchestration/actor/index.ts

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