@xyo-network/xl1-cli 1.6.2

package/src/orchestration/host/implementation/DefaultServiceCollection.ts

@@ -0,0 +1,60 @@
+import type {
+  ServiceCollection, ServiceDescriptor, ServiceProvider,
+} from '../model/index.ts'
+import { ServiceLifetime } from '../model/index.ts'
+import { DefaultServiceProvider } from './DefaultServiceProvider.ts'
+
+/**
+ * A collection of service descriptors, allowing adding/removing services before building.
+ */
+export class DefaultServiceCollection implements ServiceCollection {
+  private readonly descriptors: ServiceDescriptor[] = []
+
+  /**
+   * Register a service as Singleton: a single instance is created and shared.
+   */
+  addSingleton<T>(
+    identifier: string | symbol,
+    implementationFactory: () => T,
+  ): void {
+    this.descriptors.push({
+      identifier,
+      lifetime: ServiceLifetime.Singleton,
+      implementationFactory,
+    })
+  }
+
+  /**
+   * Register a service as Transient: a new instance is created on each request.
+   */
+  addTransient<T>(
+    _identifier: string | symbol,
+    _implementationFactory: () => T,
+  ): void {
+    throw new Error('Not implemented')
+  }
+
+  /**
+   * Build a concrete, immutable service provider from the current descriptors.
+   */
+  build(): ServiceProvider {
+    const services: Record<string, unknown> = {}
+    for (const descriptor of this.descriptors) {
+      if (descriptor.lifetime === ServiceLifetime.Singleton) {
+        services[descriptor.identifier.toString()] = descriptor.implementationFactory()
+      }
+    }
+    return new DefaultServiceProvider(services)
+  }
+
+  /**
+   * Removes all registrations matching the given identifier.
+   */
+  remove(identifier: string | symbol): void {
+    for (let i = this.descriptors.length - 1; i >= 0; i--) {
+      if (this.descriptors[i].identifier === identifier) {
+        this.descriptors.splice(i, 1)
+      }
+    }
+  }
+}

package/src/orchestration/host/implementation/DefaultServiceProvider.ts

@@ -0,0 +1,12 @@
+import type { ServiceProvider } from '../model/index.ts'
+
+export class DefaultServiceProvider implements ServiceProvider {
+  protected _services: Record<string, unknown>
+  constructor(services: Record<string, unknown>) {
+    this._services = services
+  }
+
+  getService<T>(serviceIdentifier: string): T | undefined {
+    return this._services[serviceIdentifier] as T
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './DefaultHost.ts'
+export * from './DefaultServiceProvider.ts'

package/src/orchestration/host/index.ts

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

package/src/orchestration/host/model/Host.ts

@@ -0,0 +1,21 @@
+import type { ServiceProvider } from './ServiceProvider.ts'
+
+/**
+ * Represents the host for an application.
+ */
+export interface Host {
+  /**
+   * Provides access to the application's services (for dependency injection).
+   */
+  services: ServiceProvider
+
+  /**
+   * Starts the host and any underlying services (e.g., background tasks).
+   */
+  start(): Promise<void>
+
+  /**
+   * Stops the host and attempts to gracefully shut down services.
+   */
+  stop(): Promise<void>
+}

package/src/orchestration/host/model/ServiceCollection.ts

@@ -0,0 +1,22 @@
+import type { ServiceProvider } from './ServiceProvider.ts'
+
+export interface ServiceCollection {
+  build(): ServiceProvider
+}
+
+/**
+ * Represents the lifetime of a service
+ */
+export const ServiceLifetime = {
+  Singleton: 'Singleton',
+  Transient: 'Transient',
+} as const
+
+/**
+ * Describes a single service registration
+ */
+export interface ServiceDescriptor<T = unknown> {
+  identifier: string | symbol
+  implementationFactory: () => T
+  lifetime: keyof typeof ServiceLifetime
+}

package/src/orchestration/host/model/ServiceProvider.ts

@@ -0,0 +1,3 @@
+export interface ServiceProvider {
+  getService<T = unknown>(serviceIdentifier: string): T | undefined
+}

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

@@ -0,0 +1,3 @@
+export * from './Host.ts'
+export * from './ServiceCollection.ts'
+export * from './ServiceProvider.ts'

package/src/orchestration/index.ts

@@ -0,0 +1,5 @@
+export * from './actor/index.ts'
+export * from './health/index.ts'
+export * from './initServices.ts'
+export * from './services/index.ts'
+export * from './status/index.ts'

package/src/orchestration/initServices.ts

@@ -0,0 +1,237 @@
+import { assertEx } from '@xylabs/assert'
+import { Base } from '@xylabs/base'
+import { asAddress } from '@xylabs/hex'
+import type { Logger } from '@xylabs/logger'
+import { isDefined } from '@xylabs/typeof'
+import { balanceSummaryRepositoryFromMap } from '@xyo-network/chain-modules'
+import type {
+  BaseBlockProducerServiceParams, BaseService, XyoValidatorParams,
+} from '@xyo-network/chain-services'
+import { initTelemetry } from '@xyo-network/chain-telemetry'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import { validateHydratedBlockState } from '@xyo-network/chain-validation'
+import type { ChainServiceCollectionV2 } from '@xyo-network/xl1-protocol-sdk'
+
+import {
+  initChainFinalizedArchivist, initChainSubmissionsArchivist, initPendingBundledTransactionsArchivist, initRejectedTransactionsArchivist,
+  initStakeIntentStateArchivist,
+} from './archivists/index.ts'
+import { initHealthEndpoints } from './health/initHealthEndpoints.ts'
+import { initBalanceSummaryMap } from './map/index.ts'
+import {
+  initAccount, initBalanceService, initBlockProducer, initBlockRewardService, initChainIterator, initChainService, initElectionService, initHead,
+  initPendingTransactions, initStakeIntentService,
+} from './services/index.ts'
+import { RuntimeStatusMonitor } from './status/index.ts'
+
+const telemetryConfig = {
+  attributes: {
+    serviceName: 'xl1-producer',
+    serviceVersion: '1.0.0',
+  },
+  metricsConfig: {
+    endpoint: '/metrics',
+    port: 9464,
+  },
+}
+
+interface Startable {
+  start: () => Promise<void>
+}
+
+const isStartable = (value: unknown): value is Startable => {
+  return isDefined((value as Startable).start) && typeof (value as Startable).start === 'function'
+}
+
+export const initServices = async (logger?: Logger): Promise<ChainServiceCollectionV2> => {
+  Base.defaultLogger = logger ?? console
+
+  const statusReporter = new RuntimeStatusMonitor(logger ?? console)
+  statusReporter.onGlobalTransition({ to: 'started' }, () => {
+    Base.defaultLogger?.log('All services started.')
+  })
+  statusReporter.onGlobalTransition({ to: 'error' }, () => {
+    Base.defaultLogger?.error('Producer encountered an unhandled error!')
+    // eslint-disable-next-line unicorn/no-process-exit
+    process.exit(1)
+  })
+
+  await startupSpanAsync('initHealthEndpoints', () => initHealthEndpoints({ statusReporter }))
+
+  const [
+    { traceProvider, meterProvider },
+    account,
+  ] = await Promise.all([
+    startupSpanAsync('initTelemetry', () => initTelemetry(telemetryConfig)),
+    startupSpanAsync('initAccount', () => initAccount()),
+  ])
+
+  // Archivists
+  const [
+    chainArchivist,
+    [pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite],
+    rejectedTransactionsArchivist,
+    chainSubmissionsArchivistWrite,
+    stakeIntentStateArchivist,
+    chainService,
+    balanceSummaryMap,
+  ] = await Promise.all([
+    startupSpanAsync(
+      'ChainFinalizedArchivist',
+      () => initChainFinalizedArchivist(traceProvider),
+    ),
+    startupSpanAsync(
+      'PendingBundledTransactionsArchivist',
+      () => initPendingBundledTransactionsArchivist(traceProvider),
+    ),
+    startupSpanAsync(
+      'RejectedTransactionsArchivist',
+      () => initRejectedTransactionsArchivist(traceProvider),
+    ),
+    startupSpanAsync(
+      'ChainSubmissionsArchivist',
+      () => initChainSubmissionsArchivist(),
+    ),
+    startupSpanAsync(
+      'StakeIntentStateArchivist',
+      () => initStakeIntentStateArchivist(),
+    ),
+    startupSpanAsync(
+      'ChainService',
+      () => initChainService({ account, name: 'ChainService' }),
+    ),
+    startupSpanAsync(
+      'BalanceSummaryMap',
+      () => initBalanceSummaryMap(traceProvider),
+    ),
+  ])
+
+  const chainId = chainService.chainId
+  const chainContractViewer = chainService
+  const chainStakeViewer = chainService
+  const chainStaker = chainService
+  const head = await startupSpanAsync('initHead', () => initHead({
+    account, chainArchivist, chainSubmissionsArchivistWrite,
+  }))
+  const [
+    pendingTransactionsService,
+    rewardService,
+    chainIterator,
+    balanceService,
+  ] = await Promise.all([
+    startupSpanAsync('PendingTransactions', () => initPendingTransactions({
+      name: 'PendingTransactionsService',
+      chainArchivist,
+      chainId,
+      meterProvider,
+      pendingBundledTransactionsArchivist,
+      rejectedTransactionsArchivist,
+      traceProvider,
+      statusReporter,
+    })),
+    startupSpanAsync(
+      'RewardService',
+      () => initBlockRewardService({
+        name: 'RewardService',
+        account,
+        chainService,
+        traceProvider,
+        statusReporter,
+      }),
+    ),
+    startupSpanAsync(
+      'ChainIterator',
+      () => initChainIterator({
+        name: 'ChainIterator',
+        traceProvider,
+        chainArchivist,
+        head,
+        statusReporter,
+      }),
+    ),
+    startupSpanAsync(
+      'BalanceService',
+      () => initBalanceService({
+        name: 'BalanceService',
+        chainArchivist,
+        summaryRepository: balanceSummaryRepositoryFromMap(balanceSummaryMap),
+      }),
+    ),
+  ])
+
+  const stakeIntentService = await startupSpanAsync(
+    'StakeIntentService',
+    () => initStakeIntentService({
+      name: 'StakeIntentService',
+      chainArchivist,
+      chainIterator,
+      chainStakeViewer,
+      logger: console,
+      stakeIntentStateArchivist,
+      traceProvider,
+      statusReporter,
+    }),
+  )
+
+  const electionService = await startupSpanAsync(
+    'ElectionService',
+    () => initElectionService({
+      name: 'ElectionService',
+      traceProvider,
+      chainIterator,
+      chainStakeViewer,
+      stakeIntentService,
+      statusReporter,
+    }),
+  )
+
+  const validatorParams: XyoValidatorParams = {
+    name: 'Validator',
+    account,
+    chainId,
+    pendingBundledTransactionsArchivist,
+    chainArchivist,
+    electionService,
+    rewardService,
+    stakeIntentService,
+    traceProvider,
+    validateHydratedBlockState,
+  }
+  const rewardAddress = isDefined(process.env.XYO_BLOCK_REWARD_ADDRESS)
+    ? assertEx(asAddress(process.env.XYO_BLOCK_REWARD_ADDRESS), () => 'Invalid block reward address provided')
+    : account.address
+  const producerParams: BaseBlockProducerServiceParams = {
+    ...validatorParams,
+    name: 'Producer',
+    balanceService,
+    chainArchivist,
+    pendingBundledTransactionsArchivist,
+    pendingTransactionsService,
+    rejectedTransactionsArchivist,
+    rewardAddress,
+  }
+  const producer = await startupSpanAsync('Producer', () => initBlockProducer(producerParams))
+  // TODO: Add to base service collection
+  const result: ChainServiceCollectionV2 = {
+    account,
+    balanceService,
+    chainArchivist,
+    chainContractViewer,
+    chainIterator,
+    chainStaker,
+    chainStakeViewer,
+    chainSubmissionsArchivistWrite,
+    electionService,
+    pendingBundledTransactionsArchivistWrite,
+    pendingTransactionsService,
+    producer,
+    rewardService,
+    stakeIntentService,
+  }
+
+  Base.defaultLogger?.log('All services created. Starting...')
+  const startableServices = [balanceSummaryMap, ...Object.values(result)].filter(isStartable)
+  // Start all services that have a start method
+  await Promise.all(startableServices.map(service => service.start()))
+  return result
+}

package/src/orchestration/map/BalanceSummary/index.ts

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

package/src/orchestration/map/BalanceSummary/initBalanceSummaryMap.ts

@@ -0,0 +1,22 @@
+import type { TracerProvider } from '@opentelemetry/api'
+import type { Hash } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import type { MapType } from '@xyo-network/chain-protocol'
+import { startupSpanAsync } from '@xyo-network/chain-utils'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { BalancesStepSummary } from '@xyo-network/xl1-protocol-sdk'
+import { Mutex } from 'async-mutex'
+
+import { initLocalBalanceSummaryMap } from './local.ts'
+
+const mutex = new Mutex()
+let singleton: MapType<Hash, WithStorageMeta<BalancesStepSummary>> | undefined
+
+export async function initBalanceSummaryMap(_traceProvider: TracerProvider): Promise<MapType<Hash, WithStorageMeta<BalancesStepSummary>>> {
+  return await mutex.runExclusive(async () => {
+    if (isDefined(singleton)) return singleton
+    const local = await startupSpanAsync('BalanceSummaryMap:initLocal', () => initLocalBalanceSummaryMap())
+    singleton = local
+    return singleton
+  })
+}

package/src/orchestration/map/BalanceSummary/local.ts

@@ -0,0 +1,19 @@
+import type { Hash } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import type { MapType } from '@xyo-network/chain-protocol'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type { BalancesStepSummary } from '@xyo-network/xl1-protocol-sdk'
+import { Mutex } from 'async-mutex'
+
+import { getLocalPersistentMap } from '../localPersistentMap.ts'
+
+const mutex = new Mutex()
+let singleton: MapType<Hash, WithStorageMeta<BalancesStepSummary>> | undefined
+
+export const initLocalBalanceSummaryMap = async (): Promise<MapType<Hash, WithStorageMeta<BalancesStepSummary>>> => {
+  return await mutex.runExclusive(async () => {
+    if (isDefined(singleton)) return singleton
+    singleton = await getLocalPersistentMap<Hash, WithStorageMeta<BalancesStepSummary>>('balance', 'summary')
+    return singleton
+  })
+}

package/src/orchestration/map/driver/index.ts

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

package/src/orchestration/map/driver/lmdb/Params.ts

@@ -0,0 +1,7 @@
+import type { BaseServiceParams } from '@xyo-network/chain-services'
+
+export interface LmdbMapParams extends BaseServiceParams {
+  dbName: string
+  location: string
+  storeName: string
+}

package/src/orchestration/map/driver/lmdb/SynchronousLmdbMap.ts

@@ -0,0 +1,67 @@
+import { creatable } from '@xylabs/creatable'
+import { SynchronousMap } from '@xyo-network/chain-protocol'
+import { BaseService } from '@xyo-network/chain-services'
+import {
+  Database, Key, open, RootDatabase,
+} from 'lmdb'
+
+import { LmdbMapParams } from './Params.ts'
+
+// TODO: Abstract creatable instead of service?
+/**
+ * A synchronous LMDB-backed Map implementation.
+ * This class provides a synchronous interface to an LMDB database, allowing for key-value storage.
+ * It allows for multi-tenancy within a single LMDB environment by using a root database (located
+ * at this.folderPath) and a specific DB within the environment (specified by this.params.storeName).
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ */
+@creatable()
+export class SynchronousLmdbMap<K extends Key, V> extends BaseService<LmdbMapParams> implements SynchronousMap<K, V> {
+  protected db!: Database<V, K>
+  protected rootDatabase!: RootDatabase
+
+  /**
+   * The path to the LMDB folder where the database is stored.
+   * This is constructed from the location and dbName parameters
+   * allowing for multiple DBs within the root (by specifying a
+   * different storeName).
+   * @returns The folder path for the LMDB database.
+   */
+  get folderPath() {
+    return `${this.params.location}/${this.params.dbName}`
+  }
+
+  all(): V[] {
+    return [...this.db.getRange({})].map(entry => entry.value)
+  }
+
+  clear(): void {
+    this.db.clearSync()
+  }
+
+  delete(id: K): boolean {
+    return this.db.removeSync(id)
+  }
+
+  get(id: K): V | undefined {
+    return this.db.get(id)
+  }
+
+  has(id: K): boolean {
+    return this.db.doesExist(id)
+  }
+
+  set(id: K, data: V): this {
+    this.db.putSync(id, data)
+    return this
+  }
+
+  override async startHandler(): Promise<void> {
+    await super.startHandler()
+    // Initialize the DB Environment (opens the default LMDB database)
+    this.rootDatabase = open({ path: this.folderPath })
+    // Open the desired DB (using the store name)
+    this.db = this.rootDatabase.openDB<V, K>({ name: this.params.storeName })
+  }
+}

package/src/orchestration/map/driver/lmdb/index.ts

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

package/src/orchestration/map/index.ts

@@ -0,0 +1,2 @@
+export * from './BalanceSummary/index.ts'
+export * from './driver/index.ts'

package/src/orchestration/map/localPersistentMap.ts

@@ -0,0 +1,39 @@
+import { rm } from 'node:fs/promises'
+
+import type { MapType } from '@xyo-network/chain-protocol'
+
+import type { StoreKind } from '../store/index.ts'
+import { getStoreDirectory } from '../store/index.ts'
+import { SynchronousLmdbMap } from './driver/index.ts'
+
+/**
+ * Returns a local persistent map
+ * @param dbName The name of the database
+ * @param storeName The name of the store
+ * @param kind The kind of the map
+ * @returns a map
+ */
+export const getLocalPersistentMap = async <TId, TData>(dbName: string, storeName: string, kind: StoreKind = 'lmdb'): Promise<MapType<TId, TData>> => {
+  switch (kind) {
+    case 'lmdb': {
+      const location = getStoreDirectory(dbName, 'lmdb')
+      const store = await SynchronousLmdbMap.create({
+        location, dbName, storeName,
+      })
+      return store as unknown as MapType<TId, TData>
+    }
+  }
+}
+
+export const deleteLocalPersistentMap = async (dbName: string, _storeName: string, kind: StoreKind = 'lmdb'): Promise<void> => {
+  await Promise.resolve()
+  console.warn(`Deleting local persistent map for ${dbName} of kind ${kind}.`)
+  let location = ''
+  switch (kind) {
+    case 'lmdb': {
+      location = getStoreDirectory(dbName, 'lmdb')
+      break
+    }
+  }
+  await rm(location, { recursive: true, force: true })
+}

package/src/orchestration/repository/index.ts

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

package/src/orchestration/repository/lib/index.ts

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

package/src/orchestration/repository/lib/repositoryFromArchivist.ts

@@ -0,0 +1,27 @@
+import { filterAs } from '@xylabs/array'
+import type { Hash } from '@xylabs/hex'
+import type { AnyNonPromise } from '@xylabs/promise'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import type { PayloadRepository } from '@xyo-network/xl1-protocol'
+
+export const repositoryFromArchivist = <T extends Payload = Payload>(
+  archivist: ArchivistInstance,
+  predicate: (value: AnyNonPromise) => WithStorageMeta<T>) => {
+  const repository: PayloadRepository<Hash, WithStorageMeta<T>> = {
+    get: async (hashes: Hash[]) => {
+      const payloads = await archivist.get(hashes)
+      const filtered = filterAs(payloads, predicate)
+      return filtered
+    },
+    insert: async (payloads: T[]) => {
+      const filtered = filterAs(payloads, predicate)
+      await archivist.insert(filtered)
+      return filtered
+    },
+    next: () => {
+      throw new Error('Not implemented')
+    },
+  }
+  return repository
+}

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

@@ -0,0 +1,23 @@
+import type { Promisable } from '@xylabs/promise'
+import { isUndefined } from '@xylabs/typeof'
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/chain-protocol'
+import { HDWallet } from '@xyo-network/wallet'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+
+let accountServiceSingleton: Promisable<WalletInstance> | undefined
+
+export const initAccount: Initializable<void, WalletInstance> = async (): Promise<WalletInstance> => {
+  if (accountServiceSingleton) return accountServiceSingleton
+  let walletPhrase = process.env.XYO_WALLET_MNEMONIC
+  if (isUndefined(walletPhrase)) {
+    console.log('No wallet mnemonic specified!')
+    const randomMnemonic = HDWallet.generateMnemonic()
+    console.log(`Using randomly generated mnemonic: ${randomMnemonic}`)
+    walletPhrase = randomMnemonic
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase)
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO)
+  accountServiceSingleton = account
+  return accountServiceSingleton
+}

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

@@ -0,0 +1,13 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BaseAccountBalanceServiceParams } from '@xyo-network/chain-services'
+import { BaseAccountBalanceService } from '@xyo-network/chain-services'
+import type { AccountBalanceServiceV2, Initializable } from '@xyo-network/xl1-protocol'
+
+let balanceServiceSingleton: Promisable<AccountBalanceServiceV2> | undefined
+
+export const initBalanceService: Initializable<BaseAccountBalanceServiceParams, AccountBalanceServiceV2>
+= async (params): Promise<AccountBalanceServiceV2> => {
+  if (balanceServiceSingleton) return balanceServiceSingleton
+  balanceServiceSingleton = await BaseAccountBalanceService.create(params)
+  return balanceServiceSingleton
+}

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

@@ -0,0 +1,35 @@
+import { assertEx } from '@xylabs/assert'
+import type { Address } from '@xylabs/hex'
+import { asAddress } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+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 { ContractRunner } from 'ethers'
+import { Wallet } from 'ethers/wallet'
+
+import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
+
+let chainStakeServiceSingleton: Promisable<EvmChainService> | undefined
+
+export const canUseEvmContractChainService = () => {
+  return process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS !== undefined && canUseEvmProvider()
+}
+
+export const initEvmContractChainService: Initializable<BaseAccountableServiceParams, EvmChainService> = async ({
+  account, traceProvider, meterProvider, logger,
+}) => {
+  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
+  // Parse ENV
+  const emvStakingContractAddress = assertEx(process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS, () => 'Error: XYO_EVM_STAKING_CONTRACT_ADDRESS is required')
+  // Configure wallet
+  const id: Address = assertEx(asAddress(emvStakingContractAddress), () => 'Error: XYO_EVM_STAKING_CONTRACT_ADDRESS is invalid')
+  const provider = assertEx(await initEvmProvider())
+  const privateKey = assertEx(account.private?.hex, () => 'Error: Account does not have a private key')
+  const runner: ContractRunner = new Wallet(privateKey, provider)
+  // Create service
+  chainStakeServiceSingleton = EvmChainService.create({
+    id, runner, traceProvider, meterProvider, logger,
+  })
+  return await chainStakeServiceSingleton
+}