@xyo-network/chain-orchestration 1.20.14 → 1.20.16

package/src/shared/host/implementation/DefaultHost.ts

@@ -1,25 +0,0 @@
-import type { Host, ServiceProvider } from '../model/index.ts'
-
-/**
- * A generic host implementation that can be used as a starting point for
- * more complex host implementations.
- */
-export class GenericHost implements Host {
-  services: ServiceProvider
-
-  constructor(services: ServiceProvider) {
-    this.services = services
-  }
-
-  async start(): Promise<void> {
-    await Promise.resolve()
-    // Initialize or start your services here
-    console.log('Host is starting...')
-  }
-
-  async stop(): Promise<void> {
-    await Promise.resolve()
-    // Stop or clean up services here
-    console.log('Host is stopping...')
-  }
-}

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

@@ -1,60 +0,0 @@
-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/shared/host/implementation/DefaultServiceProvider.ts

@@ -1,12 +0,0 @@
-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/shared/host/implementation/index.ts

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

package/src/shared/host/index.ts

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

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

@@ -1,21 +0,0 @@
-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/shared/host/model/ServiceCollection.ts

@@ -1,22 +0,0 @@
-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/shared/host/model/ServiceProvider.ts

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

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

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

package/src/shared/index.ts

@@ -1,8 +0,0 @@
-export * from './actor/index.ts'
-export * from './buildTelemetryConfig.ts'
-export * from './ChainInitializableParams.ts'
-export * from './config/index.ts'
-export * from './createDeclarationIntentBlock.ts'
-export * from './host/index.ts'
-export * from './init/index.ts'
-export * from './orchestrator/index.ts'

package/src/shared/init/index.ts

@@ -1,5 +0,0 @@
-export * from './initActorAccount.ts'
-export * from './initActorSeedPhrase.ts'
-export * from './initBridgedModule.ts'
-export * from './initStatusReporter.ts'
-export * from './initWallet.ts'

package/src/shared/init/initActorAccount.ts

@@ -1,28 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import { isDefined, isUndefined } from '@xylabs/sdk-js'
-import { HDWallet } from '@xyo-network/sdk-js'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
-import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/xl1-sdk'
-
-const actorAccountSingletons: Record<string, Promisable<WalletInstance>> = {}
-
-export async function initActorAccount({ config, logger }: Pick<ActorConfigContext, 'config' | 'logger'>): Promise<WalletInstance> {
-  const actorName = config.name
-  if (isDefined(actorAccountSingletons[actorName])) return actorAccountSingletons[actorName]
-  let walletPhrase = config.mnemonic
-  if (isUndefined(walletPhrase)) {
-    logger?.warn(`[${actorName}}] No wallet mnemonic specified!`)
-    const randomMnemonic = HDWallet.generateMnemonic()
-    logger?.warn(`[${actorName}}] Using randomly generated mnemonic:
-    
-${randomMnemonic}
-      
-    `)
-    walletPhrase = randomMnemonic
-  }
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase)
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO)
-  actorAccountSingletons[actorName] = account
-  return actorAccountSingletons[actorName]
-}

package/src/shared/init/initActorSeedPhrase.ts

@@ -1,29 +0,0 @@
-import { assertEx, isString } from '@xylabs/sdk-js'
-import type { BiosExternalInterface } from '@xyo-network/bios-model'
-import { HDWallet } from '@xyo-network/sdk-js'
-import type { WalletKind } from '@xyo-network/storage-model'
-import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
-
-// TODO: Make nodejs version of bios support round tripping mnemonic between boots
-export async function initActorSeedPhrase(context: ActorConfigContext, bios: BiosExternalInterface): Promise<string> {
-  const { logger, config } = context
-  const walletKind = config.name as WalletKind
-  const storedSeedPhrase = await bios.seedPhraseStore.get(walletKind)
-  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`)
-  const { mnemonic } = config
-  if (isString(storedSeedPhrase) && isString(mnemonic)) {
-    logger?.warn('[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.')
-    await bios.seedPhraseStore.set(walletKind, mnemonic)
-  } else {
-    let seedPhrase: string
-    if (isString(mnemonic)) {
-      seedPhrase = mnemonic
-    } else {
-      seedPhrase = HDWallet.generateMnemonic()
-      logger?.log('[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.')
-      logger?.log(`[API] Mnemonic: ${seedPhrase}`)
-    }
-    await bios.seedPhraseStore.set(walletKind, seedPhrase)
-  }
-  return assertEx(await bios.seedPhraseStore.get(walletKind), () => 'Unable to acquire mnemonic from bios')
-}

package/src/shared/init/initBridgedModule.ts

@@ -1,40 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  AttachableArchivistInstance, AttachableModuleInstance, BridgeInstance, ModuleIdentifier,
-} from '@xyo-network/sdk-js'
-import { asAttachableArchivistInstance, asAttachableModuleInstance } from '@xyo-network/sdk-js'
-import { Mutex } from 'async-mutex'
-
-const initMutex = new Mutex()
-type ModuleDictionary = Record<ModuleIdentifier, AttachableModuleInstance | undefined>
-type BridgedModuleDictionary = Record<Address, ModuleDictionary | undefined>
-const bridgedModuleDictionary: BridgedModuleDictionary = {}
-
-export async function initBridgedModule({ bridge, moduleName }: { bridge: BridgeInstance; moduleName: ModuleIdentifier }): Promise<AttachableModuleInstance> {
-  return await initMutex.runExclusive(async () => {
-    const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName]
-    if (existing) return existing
-    const mod = assertEx(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`)
-    const moduleInstance = assertEx(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`)
-    // Initialize the nested dictionary if needed
-    let moduleMap = bridgedModuleDictionary[bridge.address]
-    if (moduleMap === undefined) {
-      moduleMap = {}
-      bridgedModuleDictionary[bridge.address] = moduleMap
-    }
-    // Store and return the module instance
-    moduleMap[moduleName] = moduleInstance
-    return moduleInstance
-  })
-}
-
-export async function initBridgedArchivistModule({ bridge, moduleName }: {
-  bridge: BridgeInstance
-  moduleName: ModuleIdentifier
-}): Promise<AttachableArchivistInstance> {
-  return assertEx(
-    asAttachableArchivistInstance(await initBridgedModule({ bridge, moduleName })),
-    () => `Could not convert ${moduleName} to attachable archivist instance`,
-  )
-}

package/src/shared/init/initStatusReporter.ts

@@ -1,15 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-import { RuntimeStatusMonitor } from '@xyo-network/xl1-sdk'
-
-export function initStatusReporter({ logger }: { logger: Logger }) {
-  const statusReporter = new RuntimeStatusMonitor(logger)
-  statusReporter.onGlobalTransition({ to: 'started' }, () => {
-    logger.log('All services started.')
-  })
-  statusReporter.onGlobalTransition({ to: 'error' }, () => {
-    logger.error('Producer encountered an unhandled error!')
-    // eslint-disable-next-line unicorn/no-process-exit
-    process.exit(1)
-  })
-  return statusReporter
-}

package/src/shared/init/initWallet.ts

@@ -1,44 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import { boot } from '@xyo-network/bios'
-import { HDWallet } from '@xyo-network/sdk-js'
-import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
-
-import { initActorSeedPhrase } from './initActorSeedPhrase.ts'
-
-export async function initActorWallet(context: ActorConfigContext, mnemonic?: string) {
-  const bios = await boot()
-  const seedPhrase = isDefined(mnemonic)
-    ? mnemonic
-    : await initActorSeedPhrase(context, bios)
-  return await HDWallet.fromPhrase(seedPhrase)
-}
-
-// export async function initApiWallet({ config, logger }: ConfigContext) {
-//   const { mnemonic } = config.actors.api
-//   return await initWallet({ config, logger }, mnemonic)
-// }
-
-// export async function initBridgeWallet({ config, logger }: ConfigContext) {
-//   const { mnemonic } = config.actors.bridge
-//   return await initWallet({ config, logger }, mnemonic)
-// }
-
-// export async function initMempoolWallet({ config, logger }: ConfigContext) {
-//   const { mnemonic } = config.actors.mempool
-//   return await initWallet({ config, logger }, mnemonic)
-// }
-
-// export async function initProducerWallet({ config, logger }: ConfigContext) {
-//   const { mnemonic } = config.actors.producer
-//   return await initWallet({ config, logger }, mnemonic)
-// }
-
-// export async function initRewardsRedemptionApiWallet({ config, logger }: ConfigContext) {
-//   const { mnemonic } = config.actors.rewardRedemption
-//   return await initWallet({ config, logger }, mnemonic)
-// }
-
-// export async function initValidatorWallet({ config, logger }: ConfigContext) {
-//   const { mnemonic } = config.actors.mempool
-//   return await initWallet({ config, logger }, mnemonic)
-// }

package/src/shared/orchestrator/Orchestrator.ts

@@ -1,66 +0,0 @@
-import type { CreatableInstance } from '@xylabs/sdk-js'
-import { AbstractCreatable, creatable } from '@xylabs/sdk-js'
-import { ActorInstanceV3 } from '@xyo-network/xl1-sdk'
-
-export interface OrchestratorInstance extends CreatableInstance {
-  registerActor(actor: ActorInstanceV3): Promise<void>
-}
-
-@creatable()
-export class Orchestrator extends AbstractCreatable implements OrchestratorInstance {
-  protected actors: (ActorInstanceV3)[] = []
-  protected keepAliveHandle: NodeJS.Timeout | null = null
-  protected running = false
-
-  /**
-   * Registers an actor.
-   * (We won't activate the actor until `start()` is called.)
-   */
-  async registerActor(actor: ActorInstanceV3) {
-    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.
-   */
-  override async startHandler() {
-    await super.startHandler()
-    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.
-   */
-  override async stopHandler() {
-    await super.stopHandler()
-    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/shared/orchestrator/index.ts

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