@xyo-network/xl1-cli-lib 1.17.0 → 1.17.2

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

@@ -1,302 +0,0 @@
-import type { Attributes, Counter } from '@opentelemetry/api'
-import type { Promisable } from '@xylabs/sdk-js'
-import {
-  assertEx, isDefined, isUndefined, toHex,
-} from '@xylabs/sdk-js'
-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, HydratedBlockWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol'
-import { asXL1BlockNumber } 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 { Mutex } from 'async-mutex'
-
-import type { ActorParams } from '../model/index.ts'
-import { Actor } from '../model/index.ts'
-
-export type ProducerActorParams = ActorParams<
-  Pick<
-    ChainServiceCollectionV2,
-    'account'
-    | 'balance'
-    | 'blockViewer'
-    | 'chainStakeViewer'
-    | 'chainSubmissionsArchivistWrite'
-    | 'pendingBundledTransactionsArchivistWrite'
-    | 'producer'
-    | 'stakeIntent'
-  >
->
-
-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: HydratedBlockWithHashMeta | undefined
-  protected _lastRedeclarationIntent: ChainStakeIntent | undefined
-  protected readonly _metricAttributes: Attributes
-  protected readonly _producerActorBlockProductionAttempts: Counter<Attributes> | undefined
-  protected readonly _producerActorBlockProductionChecks: Counter<Attributes> | undefined
-  protected readonly _producerActorBlocksProduced: Counter<Attributes> | undefined
-  protected readonly _producerActorBlocksPublished: Counter<Attributes> | undefined
-
-  private _produceBlockMutex = new Mutex()
-
-  protected constructor(params: ProducerActorParams) {
-    super(params.producer.address, 'Producer', params)
-    // Create the consistent meter attributes that will
-    // be included with all metrics from this actor
-    this._metricAttributes = { address: this.account.address.toString() }
-    // Create the metrics
-    this._producerActorBlockProductionChecks = this.meter?.createCounter(
-      'producer_actor_block_production_checks',
-      { description: 'Number of block production checks' },
-    )
-    this._producerActorBlockProductionAttempts = this.meter?.createCounter(
-      'producer_actor_block_production_attempts',
-      { description: 'Number of block production attempts' },
-    )
-    this._producerActorBlocksProduced = this.meter?.createCounter(
-      'producer_actor_blocks_produced',
-      { description: 'Number of blocks produced' },
-    )
-    this._producerActorBlocksPublished = this.meter?.createCounter(
-      'producer_actor_blocks_published',
-      { description: 'Number of blocks published' },
-    )
-  }
-
-  protected get account() {
-    return assertEx(this.params.account, () => 'account not set')
-  }
-
-  protected get balanceService() {
-    return assertEx(this.params.balance, () => 'balanceService not set')
-  }
-
-  protected get blockViewer() {
-    return assertEx(this.params.blockViewer, () => 'blockViewer 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.stakeIntent, () => 'stakeIntentService not set')
-  }
-
-  static create(params: ProducerActorParams): Promisable<ProducerActor> {
-    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.produceBlock()
-    }, 2000, 1500/* 500 */)
-
-    if (SHOULD_REGISTER_REDECLARATION_INTENT_TIMER) {
-      // Register a timer to check if we should redeclare the producer
-      this.registerTimer('ProducerRedeclarationTimer', async () => {
-        await this.redeclareIntent()
-      }, TEN_MINUTES, 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 produceBlock(): Promise<void> {
-    this._producerActorBlockProductionChecks?.add(1, this._metricAttributes)
-    await this.spanAsync('produceBlock', async () => {
-      if (this._produceBlockMutex.isLocked()) {
-        this.logger?.log('Skipping block production, previous production still in progress')
-        return
-      }
-
-      await this._produceBlockMutex.runExclusive(async () => {
-      // Get the updated head
-        const headStart = Date.now()
-        const head = (await this.blockViewer.currentBlock())[0]
-        const headDuration = Date.now() - headStart
-        if (headDuration > 500) this.logger?.warn(`[Slow] Fetched head in ${headDuration}ms: 0x${toHex(head._hash)}`)
-        // Check if we've already produced the next block for this head
-        const headHash = head._hash
-        // 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)}`, this._lastProducedBlock[0].block)
-        } else {
-          this._producerActorBlockProductionAttempts?.add(1, this._metricAttributes)
-          // Produce the next block
-          const nextStart = Date.now()
-          const nextBlock = await this.producer.next(head)
-          const nextDuration = Date.now() - nextStart
-          if (nextDuration > 1000) this.logger?.warn(`[Slow] Generated next block in ${nextDuration}ms, block: ${nextBlock?.[0]._hash}`)
-          // If it was produced
-          if (nextBlock) {
-            const displayBlockNumber = `0x${toHex(nextBlock[0].block)}`
-            this.logger?.log('Produced block:', displayBlockNumber)
-            this._producerActorBlocksProduced?.add(1, this._metricAttributes)
-            // Insert the block into the chain
-            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock))
-            this.logger?.log('Published block:', displayBlockNumber, nextBlock[0].block)
-            this._producerActorBlocksPublished?.add(1, this._metricAttributes)
-            // Record that we have produced a block so we do not produce it again
-            this._lastProducedBlock = nextBlock
-          }
-        }
-      })
-    })
-  }
-
-  protected async redeclareIntent(): Promise<void> {
-    await this.spanAsync('redeclareIntent', async () => {
-      // Decide if we should redeclare intent
-      if (this.params.config.producer.disableIntentRedeclaration) return
-
-      // Get the current block
-      const head = (await this.blockViewer.currentBlock())[0]
-      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 ${this.params.config.chain.id}`
-          + ' 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
-    })
-  }
-
-  protected async submitRedeclarationIntent(currentBlock: XL1BlockNumber, 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(
-      await this.chainStakeViewer.chainId(),
-      [redeclarationIntent],
-      [],
-      this.account,
-      currentBlock,
-      asXL1BlockNumber(currentBlock + 1000, true),
-    )
-    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.accountsBalances([this.account.address], head)
-      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> {
-    // Use StakeIntentService to get the required minimum stake
-    const requiredMinimumStake = this.stakeIntentService.getRequiredMinimumStakeForIntent('producer')
-    // Check if we have a valid stake before declaring intent
-    const currentStake = await this.chainStakeViewer.activeByStaked(this.account.address)
-    if (currentStake < requiredMinimumStake) {
-      this.logger?.error(`Producer ${this.account.address} has insufficient stake.`)
-      return false
-    }
-    return true
-  }
-}

package/src/orchestration/actor/model/Actor.ts

@@ -1,167 +0,0 @@
-import type { BaseParams, EmptyObject } from '@xylabs/sdk-js'
-import {
-  Base, delay, IdLogger,
-} from '@xylabs/sdk-js'
-import { span, spanRootAsync } from '@xylabs/telemetry'
-import type { Config } from '@xyo-network/xl1-protocol-sdk'
-import { Semaphore } from 'async-mutex'
-
-export interface IActor {
-  start(): Promise<void>
-  stop(): Promise<void>
-}
-
-export type ActorParams<T extends EmptyObject | void = void> = BaseParams<{
-  config: Config
-  name: string
-} & (T extends void ? EmptyObject : T)>
-
-export class Actor<TParams extends ActorParams = ActorParams> extends Base<TParams> implements IActor {
-  protected readonly _intervals: Map<string, ReturnType<typeof setInterval>> = new Map()
-  protected readonly _semaphores: Map<string, Semaphore> = new Map()
-  protected readonly _timeouts: Map<string, ReturnType<typeof setTimeout>> = new Map()
-  private _active = false
-  private readonly _displayName: string
-  private readonly _id: string
-
-  constructor(id: string, displayName: string = 'Actor', params: TParams) {
-    const logger = params.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `)
-    super({ ...params, logger })
-    this._displayName = displayName
-    this._id = id
-  }
-
-  get displayName() {
-    return this._displayName
-  }
-
-  get id() {
-    return this._id
-  }
-
-  get name() {
-    return this.params.name
-  }
-
-  protected get logPrefix() {
-    return `[${this.displayName} (${this.id})] `
-  }
-
-  /**
-   * The timer runs until the actor is deactivated (or you manually stop it).
-   */
-  registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number) {
-    if (!this._active) {
-      this.logger?.warn(
-        `Cannot register timer '${timerName}' because actor is not active.`,
-      )
-      return
-    }
-
-    let running = false
-
-    this._semaphores.set(timerName, new Semaphore(1))
-
-    const timeoutId = setTimeout(() => {
-      const intervalId = setInterval(() => {
-        const semaphore = this._semaphores.get(timerName)
-        if (!this._active || !this._intervals.has(timerName) || !semaphore || running) return
-        if (semaphore.isLocked()) {
-          this.logger?.warn(
-            `Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`,
-          )
-          return
-        }
-        semaphore.acquire().then(([, release]) => {
-          const startTime = Date.now()
-          running = true
-          callback()
-            .then(() => {
-              const duration = Date.now() - startTime
-              if (duration > periodMs) {
-                this.logger?.warn(
-                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`,
-                )
-              } else if (duration > 5000) {
-                this.logger?.warn(
-                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`,
-                )
-              }
-            })
-            .catch((error) => {
-              this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
-            })
-            .finally(() => {
-              release()
-              running = false
-            })
-        }).catch((error) => {
-          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`)
-        })
-      }, periodMs)
-
-      // store interval so we can clear it on stop()
-      this._intervals.set(timerName, intervalId)
-    }, dueTimeMs)
-
-    // store timeout so we can clear it on stop() if interval hasn't started yet
-    this._timeouts.set(timerName, timeoutId)
-
-    this.logger?.log(
-      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
-    )
-  }
-
-  span<T>(name: string, fn: () => T): T {
-    return span(`${this.name}:${name}`, fn, this.tracer)
-  }
-
-  async spanAsync<T>(name: string, fn: () => Promise<T>): Promise<T> {
-    return await spanRootAsync(`${this.name}:${name}`, fn, this.tracer)
-  }
-
-  /**
-   * Called by the Orchestrator when the actor is activated.
-   */
-  async start() {
-    await Promise.resolve()
-    this._active = true
-    this.logger?.log('Started.')
-  }
-
-  /**
-   * Called by the Orchestrator when the actor is deactivated.
-   * Stop all running timers.
-   */
-  async stop() {
-    await Promise.resolve()
-    this._active = false
-    this.logger?.log('Stopping all timers...')
-
-    // wait for all semaphores to be free and acquire them to prevent new tasks from starting
-    await Promise.all(
-      [...this._semaphores.values()].map(async (semaphore) => {
-        // Wait for any running tasks to complete
-        while (semaphore.isLocked()) {
-          this.logger?.log('Waiting for running timer task to complete...')
-          await delay(500)
-        }
-        await semaphore.acquire()
-      }),
-    )
-
-    this._semaphores.clear()
-
-    for (const [, timeoutRef] of this._timeouts.entries()) {
-      clearTimeout(timeoutRef)
-    }
-    this._timeouts.clear()
-
-    for (const [, intervalRef] of this._intervals.entries()) {
-      clearInterval(intervalRef)
-    }
-    this._intervals.clear()
-
-    this.logger?.log('Stopped.')
-  }
-}

package/src/orchestration/actor/model/Orchestrator.ts

@@ -1,71 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-
-import type { IActor } from './Actor.ts'
-
-export interface IOrchestrator {
-  start(): Promise<void>
-  stop(): Promise<void>
-}
-
-export class Orchestrator implements IOrchestrator {
-  protected actors: IActor[] = []
-  protected keepAliveHandle: NodeJS.Timeout | null = null
-  protected readonly logger?: Logger
-  protected running = false
-
-  constructor(logger?: Logger) {
-    this.logger = logger
-  }
-
-  /**
-   * Registers an actor.
-   * (We won't activate the actor until `start()` is called.)
-   */
-  async registerActor(actor: IActor) {
-    if (this.running) {
-      // If the orchestrator is already running, activate the actor immediately
-      await actor.start()
-    }
-    this.actors.push(actor)
-  }
-
-  /**
-   * Starts the orchestrator: activates all actors.
-   */
-  async start() {
-    await Promise.resolve()
-    if (this.running) {
-      this.logger?.warn('[Orchestrator] Already started.')
-      return
-    }
-
-    this.logger?.log('[Orchestrator] Starting...')
-    this.running = true
-    for (const actor of this.actors) {
-      await actor.start()
-    }
-    // This interval will fire every 24.8 days (2^31 - 1 ms), effectively never finishing
-    this.keepAliveHandle = setInterval(() => {
-      // No-op
-    }, 2_147_483_647)
-  }
-
-  /**
-   * Stops the orchestrator: deactivates all actors.
-   */
-  async stop() {
-    await Promise.resolve()
-    if (!this.running) {
-      this.logger?.log('[Orchestrator] Already stopped.')
-      return
-    }
-
-    this.logger?.log('[Orchestrator] Stopping...')
-    for (const actor of this.actors) {
-      await actor.stop()
-    }
-    this.running = false
-    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle)
-    this.logger?.log('[Orchestrator] Stopped...')
-  }
-}

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

@@ -1,2 +0,0 @@
-export * from './Actor.ts'
-export * from './Orchestrator.ts'

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

@@ -1,29 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { AccountBalanceViewer, Config } from '@xyo-network/xl1-protocol-sdk'
-import {
-  AccountBalanceViewerRpcSchemas,
-  HttpRpcTransport,
-  JsonRpcAccountBalanceViewer,
-} from '@xyo-network/xl1-rpc'
-
-let balanceServiceSingleton: Promisable<AccountBalanceViewer> | undefined
-
-export type InitAccountBalanceServiceParams = InitializableParams<{
-  config: Config
-}>
-
-export const initAccountBalanceService: Initializable<InitAccountBalanceServiceParams, AccountBalanceViewer>
-  = (params): Promisable<AccountBalanceViewer> => {
-    const { config, logger } = params
-    if (balanceServiceSingleton) return balanceServiceSingleton
-    const endpoint = config.services?.accountBalanceViewerEndpoint ?? config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...AccountBalanceViewerRpcSchemas })
-      const viewer = new JsonRpcAccountBalanceViewer(transport)
-      logger?.log('Using AccountBalanceViewer RPC service at', endpoint)
-      return viewer
-    } else {
-      throw new Error('No AccountBalanceViewer endpoint configured')
-    }
-  }

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

@@ -1,29 +0,0 @@
-import { isDefined, type Promisable } from '@xylabs/sdk-js'
-import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
-import type { BlockViewer, Config } from '@xyo-network/xl1-protocol-sdk'
-import {
-  BlockViewerRpcSchemas,
-  HttpRpcTransport,
-  JsonRpcBlockViewer,
-} from '@xyo-network/xl1-rpc'
-
-let blockViewerSingleton: Promisable<BlockViewer> | undefined
-
-export type InitBlockViewerParams = InitializableParams<{
-  config: Config
-}>
-
-export const initBlockViewer: Initializable<InitBlockViewerParams, BlockViewer>
-  = (params): Promisable<BlockViewer> => {
-    const { config, logger } = params
-    if (blockViewerSingleton) return blockViewerSingleton
-    const endpoint = config.services?.apiEndpoint
-    if (isDefined(endpoint)) {
-      const transport = new HttpRpcTransport(endpoint, { ...BlockViewerRpcSchemas })
-      const viewer = new JsonRpcBlockViewer(transport)
-      logger?.log('Using BlockViewer RPC service at', endpoint)
-      return viewer
-    } else {
-      throw new Error('No BlockViewer endpoint configured')
-    }
-  }

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

@@ -1,39 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx, isDefined, ZERO_ADDRESS,
-} from '@xylabs/sdk-js'
-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: Pick<Config, 'chain' | 'evm'>) => {
-  const { id } = config.chain
-  return isDefined(id) && id !== ZERO_ADDRESS && canUseEvmProvider({ config })
-}
-
-export const initEvmContractChainService: Initializable<BaseAccountableServiceParams<Pick<Config, 'chain' | 'evm'>>, EvmChainService> = async ({
-  account, config, traceProvider, meterProvider, logger,
-}) => {
-  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
-  // Parse config
-  const emvStakingContractAddress = assertEx(config.chain.id, () => 'config.chain.id is required')
-  // Configure ContractRunner
-  const id: Address = assertEx(asAddress(emvStakingContractAddress), () => 'config.chain.id is not a valid address')
-  const provider = assertEx(await initEvmProvider({ config }))
-  const privateKey = assertEx(account.private?.hex, () => 'Account does not have a private key')
-  const runner: ContractRunner = new Wallet(privateKey, provider)
-  // Create service
-  chainStakeServiceSingleton = EvmChainService.create({
-    id, runner, traceProvider, meterProvider, logger,
-  })
-  const result = await chainStakeServiceSingleton
-  await result.start()
-  return result
-}

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

@@ -1,45 +0,0 @@
-import {
-  assertEx, type CreatableName, type Promisable,
-} from '@xylabs/sdk-js'
-import { type BaseAccountableServiceParams, MemoryChainService } from '@xyo-network/chain-services'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-import type { Config } from 'cosmiconfig'
-
-import { canUseEvmContractChainService, initEvmContractChainService } from './evm.ts'
-
-let chainStakeServiceSingleton: Promisable<ChainService> | undefined
-
-export const initChainService: Initializable<BaseAccountableServiceParams<
-  Pick<Config, 'chain' | 'evm' | 'producer'>>,
-ChainService> = ({
-  account, config, logger,
-}) => {
-  logger?.log('ChainService: Initializing...')
-  const result = init({
-    config, name: 'ChainService' as CreatableName, account,
-  })
-  logger?.log('ChainService: Initialized')
-  return result
-}
-
-export const initMemoryChainService: Initializable<BaseAccountableServiceParams<
-  Pick<Config, 'producer'>>, ChainService> = async ({ config }) => {
-  const result = await MemoryChainService.create({
-    config,
-    name: 'MemoryChainService' as CreatableName,
-  })
-  assertEx(await result.start(), () => 'Failed to start MemoryChainService')
-  return result
-}
-
-const init: Initializable<BaseAccountableServiceParams<Pick<Config, 'chain' | 'evm' | 'producer'>>,
-  ChainService> = async (params): Promise<ChainService> => {
-  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
-  const { config } = params
-  chainStakeServiceSingleton = canUseEvmContractChainService(config)
-    ? await initEvmContractChainService({ ...params, name: 'ChainStakeService' as CreatableName })
-    : await initMemoryChainService(params)
-  // Create service
-  return chainStakeServiceSingleton
-}