@xyo-network/chain-orchestration 1.19.6 → 1.19.8

package/src/evm/index.ts

@@ -1 +1,4 @@
+export * from './initChainId.ts'
 export * from './initEvmProvider.ts'
+export * from './initInfuraProvider.ts'
+export * from './initJsonRpcProvider.ts'

package/src/evm/initChainId.ts

@@ -3,11 +3,11 @@ import {
 } from '@xylabs/sdk-js'
 import type { Config } from '@xyo-network/xl1-sdk'
 
-export const canUseChainId = (config: Pick<Config, 'evm'>): boolean => {
+export const canUseChainId = (config: Config): boolean => {
   return isDefined(config.evm.chainId)
 }
 
-export const getChainId = (config: Pick<Config, 'evm'>) => {
+export const getChainId = (config: Config) => {
   const chainId = assertEx(config.evm.chainId, () => 'Missing config.evm.chainId')
   if (isHex(chainId, { prefix: true })) {
     const hex = hexFrom(chainId)

package/src/evm/initEvmProvider.ts

@@ -2,14 +2,13 @@ import type { Logger } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
 import type { Config } from '@xyo-network/xl1-sdk'
 import type { Provider } from 'ethers'
-import type { JsonRpcProvider } from 'ethers/providers'
 
 import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
 import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvider.ts'
 
-let provider: Promise<JsonRpcProvider> | undefined
+let provider: Promise<Provider> | undefined
 
-export const initEvmProvider = async ({ config }: { config: Pick<Config, 'evm'>; logger?: Logger }): Promise<Provider> => {
+export const initEvmProvider = async ({ config }: { config: Config; logger?: Logger }): Promise<Provider> => {
   if (provider) return provider
   if (canUseInfuraProvider(config)) {
     provider = initInfuraProvider(config)
@@ -19,6 +18,6 @@ export const initEvmProvider = async ({ config }: { config: Pick<Config, 'evm'>;
   return assertEx(await provider, () => 'No provider available')
 }
 
-export const canUseEvmProvider = ({ config }: { config: Pick<Config, 'evm'> }) => {
+export const canUseEvmProvider = ({ config }: { config: Config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config)
 }

package/src/evm/initInfuraProvider.ts

@@ -1,25 +1,26 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
 import type { Config } from '@xyo-network/xl1-sdk'
+import type { Provider } from 'ethers'
 import { InfuraProvider } from 'ethers/providers'
 
 import { canUseChainId, getChainId } from './initChainId.ts'
 
 let instance: Promise<InfuraProvider> | undefined
 
-export const initInfuraProvider = (config: Pick<Config, 'evm'>) => {
+export const initInfuraProvider = (config: Config): Promise<Provider> => {
   if (instance) return instance
   const providerConfig = getInfuraProviderConfig(config)
-  instance = Promise.resolve(new InfuraProvider(...providerConfig))
+  instance = Promise.resolve(new InfuraProvider(providerConfig[0], providerConfig[1]))
   return instance
 }
 
-export const canUseInfuraProvider = (config: Pick<Config, 'evm'>): boolean => {
+export const canUseInfuraProvider = (config: Config): boolean => {
   return canUseChainId(config)
     && isDefined(config.evm?.infura?.projectId)
     && isDefined(config.evm?.infura?.projectSecret)
 }
 
-export const getInfuraProviderConfig = (config: Pick<Config, 'evm'>) => {
+export const getInfuraProviderConfig = (config: Config) => {
   const projectId = assertEx(config.evm?.infura?.projectId, () => 'Missing config.evm.infura.projectId')
   const projectSecret = assertEx(config.evm?.infura?.projectSecret, () => 'Missing config.evm.infura.projectSecret')
   return [getChainId(config), projectId, projectSecret] as const

package/src/evm/initJsonRpcProvider.ts

@@ -4,17 +4,17 @@ import { JsonRpcProvider } from 'ethers/providers'
 
 import { canUseChainId, getChainId } from './initChainId.ts'
 
-export const initJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
+export const initJsonRpcProvider = (config: Config) => {
   const providerConfig = getJsonRpcProviderConfig(config)
   return Promise.resolve(new JsonRpcProvider(...providerConfig))
 }
 
-export const canUseJsonRpcProvider = (config: Pick<Config, 'evm'>) => {
+export const canUseJsonRpcProvider = (config: Config) => {
   return canUseChainId(config)
     && isDefined(config.evm.jsonRpc?.url)
 }
 
-export const getJsonRpcProviderConfig = (config: Pick<Config, 'evm'>) => {
+export const getJsonRpcProviderConfig = (config: Config) => {
   const jsonRpcUrl = assertEx(config.evm.jsonRpc?.url, () => 'Missing config.evm.jsonRpc.url')
   return [jsonRpcUrl, getChainId(config)] as const
 }

package/src/health/initHealthEndpoints.ts

@@ -65,6 +65,6 @@ export const initHealthEndpoints: Initializable<{ config: Config; logger: Logger
   const {
     config, logger, statusReporter,
   } = params
-  const { healthCheckPort } = config.producer
+  const { healthCheckPort } = config.actors.producer
   return isDefined(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : undefined
 }

package/src/init/index.ts

@@ -1,6 +1,7 @@
 export * from './initBalanceSummaryMap.ts'
 export * from './initBridgedModule.ts'
-export * from './initChainStakeViewer.ts'
+export * from './initEvmProvidersIfAvailable.ts'
+export * from './initFinalizationArchivistIfNeeded.ts'
 export * from './initFinalizedArchivist.ts'
 export * from './initProducerAccount.ts'
 export * from './initSeedPhrase.ts'

package/src/init/initEvmProvidersIfAvailable.ts

@@ -0,0 +1,90 @@
+import { asEthAddress, assertEx } from '@xylabs/sdk-js'
+import {
+  EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer,
+} from '@xyo-network/chain-ethereum'
+import type {
+  ChainId,
+  Position,
+  ProviderFactoryLocatorInstance,
+} from '@xyo-network/xl1-sdk'
+import {
+  SimpleChainContractViewer,
+  SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer,
+  XYO_ZERO_ADDRESS,
+} from '@xyo-network/xl1-sdk'
+
+import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
+
+export async function initEvmProvidersIfAvailable(locator: ProviderFactoryLocatorInstance) {
+  const { config, logger } = locator.context
+  if (canUseEvmProvider({ config })) {
+    const chainId = assertEx(config.chain.id as ChainId, () => 'Missing config.chain.chainId (required for EVM providers)')
+    const provider = await initEvmProvider({ config, logger })
+    const address = asEthAddress(chainId, true)
+
+    // Register the contract events viewer
+    locator.register(EvmStakeEventsViewer.factory<EvmStakeEventsViewer>(
+      EvmStakeEventsViewer.dependencies,
+      { address, provider },
+    ))
+
+    // Register the stake viewer
+    locator.register(EvmStakeViewer.factory<EvmStakeViewer>(
+      EvmStakeViewer.dependencies,
+      { address, provider },
+    ))
+
+    // Register the stake totals viewer
+    locator.register(EvmStakeTotalsViewer.factory<EvmStakeTotalsViewer>(
+      EvmStakeTotalsViewer.dependencies,
+      { address, provider },
+    ))
+
+    // Register the contract viewer
+    locator.register(EvmChainContractViewer.factory<EvmChainContractViewer>(
+      EvmChainContractViewer.dependencies,
+      { address, provider },
+    ))
+
+    locator.register(SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(
+      SimpleTimeSyncViewer.dependencies,
+      { ethProvider: provider },
+    ))
+  } else {
+    logger?.warn('EVM provider not available - running with memory based contract/stake viewers')
+    const positions: Position[] = []
+    const chainId = assertEx(config.chain.id, () => 'Missing config.chain.chainId (required for non-EVM providers)')
+
+    // Register the contract events viewer
+    locator.register(SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(
+      SimpleStakeEventsViewer.dependencies,
+      { positions },
+    ))
+
+    // Register the stake viewer
+    locator.register(SimpleStakeViewer.factory<SimpleStakeViewer>(
+      SimpleStakeViewer.dependencies,
+      { positions },
+    ))
+
+    // Register the stake totals viewer
+    locator.register(SimpleStakeTotalsViewer.factory<SimpleStakeTotalsViewer>(
+      SimpleStakeTotalsViewer.dependencies,
+      {},
+    ))
+
+    // Register the contract viewer
+    locator.register(SimpleChainContractViewer.factory<SimpleChainContractViewer>(
+      SimpleChainContractViewer.dependencies,
+      {
+        chainId, minWithdrawalBlocks: 10, stakingTokenAddress: XYO_ZERO_ADDRESS, rewardsContract: XYO_ZERO_ADDRESS,
+      },
+    ))
+
+    locator.register(SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(
+      SimpleTimeSyncViewer.dependencies,
+      {},
+    ))
+  }
+  return locator
+}

package/src/init/initFinalizationArchivistIfNeeded.ts

@@ -0,0 +1,42 @@
+import { assertEx } from '@xylabs/sdk-js'
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { createBootstrapHead } from '@xyo-network/chain-sdk'
+import {
+  asAttoXL1,
+  type ChainId, type Config, findMostRecentBlock,
+  flattenHydratedBlock,
+  type SignedBlockBoundWitnessWithHashMeta,
+} from '@xyo-network/xl1-sdk'
+
+export async function initFinalizationArchivistIfNeeded(
+  archivist: ArchivistInstance,
+  config: Config,
+  account: AccountInstance,
+): Promise<[SignedBlockBoundWitnessWithHashMeta, ChainId]> {
+  const configuredChainId = config.chain.id
+  const possibleHead = await findMostRecentBlock(archivist)
+  if (configuredChainId && possibleHead && possibleHead.chain !== configuredChainId) {
+    throw new Error(`Configured chain ID (${configuredChainId}) does not match the existing chain ID (${possibleHead.chain})`)
+  }
+
+  let possibleChainId: ChainId | undefined = configuredChainId
+
+  // if there is no configured chain ID and no head, create a new chain
+  if (!possibleHead) {
+    possibleChainId = possibleChainId ?? (await Account.random()).address
+    // If there is no head, create one
+    const chain = await createBootstrapHead(
+      account,
+      possibleChainId,
+      asAttoXL1(20_000_000_000_000_000_000_000n),
+      config.chain.genesisRewardAddress ?? account.address,
+    )
+    const payloads = chain.flatMap(block => flattenHydratedBlock(block))
+    await archivist.insert(payloads)
+  }
+  const head = possibleHead ?? assertEx(await findMostRecentBlock(archivist), () => 'No blocks found in chain archivist')
+  const chainId = assertEx(possibleChainId, () => 'Chain ID could not be determined')
+  return [head, chainId]
+}

package/src/init/initProducerAccount.ts

@@ -12,7 +12,7 @@ let accountServiceSingleton: Promisable<WalletInstance> | undefined
 export const initProducerAccount: Initializable<InitializableParams<{ config: Config }>, WalletInstance>
   = async ({ config, logger }): Promise<WalletInstance> => {
     if (accountServiceSingleton) return accountServiceSingleton
-    let walletPhrase = config.producer.mnemonic
+    let walletPhrase = config.actors.producer.mnemonic
     if (isUndefined(walletPhrase)) {
       logger?.warn('[Producer] No wallet mnemonic specified!')
       const randomMnemonic = HDWallet.generateMnemonic()

package/src/init/initSeedPhrase.ts

@@ -10,7 +10,7 @@ export async function initSeedPhrase({
 }: ConfigContext<{ bios: BiosExternalInterface }>): Promise<string> {
   const storedSeedPhrase = await bios.seedPhraseStore.get('os')
   logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`)
-  const { mnemonic } = config.api
+  const { mnemonic } = config.actors.api
   if (isString(storedSeedPhrase) && isString(mnemonic)) {
     logger?.warn('[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.')
     await bios.seedPhraseStore.set('os', mnemonic)

package/src/init/initWallet.ts

@@ -16,21 +16,21 @@ async function initWallet({ config, logger }: ConfigContext, mnemonic?: string)
 }
 
 export async function initApiWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.api
+  const { mnemonic } = config.actors.api
   return await initWallet({ config, logger }, mnemonic)
 }
 
 export async function initMempoolWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.mempool
+  const { mnemonic } = config.actors.mempool
   return await initWallet({ config, logger }, mnemonic)
 }
 
 export async function initProducerWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.producer
+  const { mnemonic } = config.actors.producer
   return await initWallet({ config, logger }, mnemonic)
 }
 
 export async function initRewardsRedemptionApiWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.rewardRedemptionApi
+  const { mnemonic } = config.actors.rewardRedemption
   return await initWallet({ config, logger }, mnemonic)
 }

package/src/orchestrator/Orchestrator.ts

@@ -1,14 +1,16 @@
 import type { CreatableInstance } from '@xylabs/sdk-js'
 import { AbstractCreatable, creatable } from '@xylabs/sdk-js'
-import { ActorInstance } from '@xyo-network/xl1-sdk'
+import {
+  ActorInstance, ActorInstanceV2, ActorInstanceV3,
+} from '@xyo-network/xl1-sdk'
 
 export interface OrchestratorInstance extends CreatableInstance {
-  registerActor(actor: ActorInstance): Promise<void>
+  registerActor(actor: ActorInstance | ActorInstanceV2 | ActorInstanceV3): Promise<void>
 }
 
 @creatable()
 export class Orchestrator extends AbstractCreatable implements OrchestratorInstance {
-  protected actors: ActorInstance[] = []
+  protected actors: (ActorInstance | ActorInstanceV2 | ActorInstanceV3)[] = []
   protected keepAliveHandle: NodeJS.Timeout | null = null
   protected running = false
 
@@ -16,7 +18,7 @@ export class Orchestrator extends AbstractCreatable implements OrchestratorInsta
    * Registers an actor.
    * (We won't activate the actor until `start()` is called.)
    */
-  async registerActor(actor: ActorInstance) {
+  async registerActor(actor: ActorInstance | ActorInstanceV2 | ActorInstanceV3) {
     if (this.running) {
       // If the orchestrator is already running, activate the actor immediately
       await actor.start()

package/dist/neutral/init/initChainStakeViewer.d.ts

@@ -1,10 +0,0 @@
-import { type Logger } from '@xylabs/sdk-js';
-import type { Config, CreatableProviderContext, StakeViewer } from '@xyo-network/xl1-sdk';
-export declare function initEvmChainStakeViewer(context: CreatableProviderContext, config: Config, logger?: Logger): Promise<StakeViewer>;
-export declare function initSimpleStakeViewer(context: CreatableProviderContext, config: Config, logger?: Logger): Promise<StakeViewer>;
-export declare function initStakeViewer({ config, logger, context, }: {
-    config: Config;
-    context: CreatableProviderContext;
-    logger?: Logger;
-}): Promise<StakeViewer>;
-//# sourceMappingURL=initChainStakeViewer.d.ts.map

package/dist/neutral/init/initChainStakeViewer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"initChainStakeViewer.d.ts","sourceRoot":"","sources":["../../../src/init/initChainStakeViewer.ts"],"names":[],"mappings":"AAAA,OAAO,EAEK,KAAK,MAAM,EACtB,MAAM,gBAAgB,CAAA;AAIvB,OAAO,KAAK,EAEV,MAAM,EACN,wBAAwB,EAAE,WAAW,EACtC,MAAM,sBAAsB,CAAA;AAK7B,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAatI;AAED,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CASpI;AAED,wBAAsB,eAAe,CAAC,EACpC,MAAM,EAAE,MAAM,EAAE,OAAO,GACxB,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,wBAAwB,CAAA;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,WAAW,CAAC,CAOvB"}

package/src/init/initChainStakeViewer.ts

@@ -1,56 +0,0 @@
-import {
-  asAddress,
-  assertEx, type Logger, toAddress, toEthAddress,
-} from '@xylabs/sdk-js'
-import type { EvmStakeEventsParams, EvmStakeViewerParams } from '@xyo-network/chain-sdk'
-import { EvmStakeEventsViewer, EvmStakeViewer } from '@xyo-network/chain-sdk'
-import { IStakedXyoChain__factory } from '@xyo-network/typechain'
-import type {
-  ChainId,
-  Config,
-  CreatableProviderContext, StakeViewer,
-} from '@xyo-network/xl1-sdk'
-import { SimpleStakeViewer } from '@xyo-network/xl1-sdk'
-
-import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
-
-export async function initEvmChainStakeViewer(context: CreatableProviderContext, config: Config, logger?: Logger): Promise<StakeViewer> {
-  const provider = await initEvmProvider({ config, logger })
-  const contractAddress = assertEx(config.chain.id, () => 'Missing config.evm.chainId') as ChainId
-  const contract = IStakedXyoChain__factory.connect(toEthAddress(contractAddress), provider)
-  const stakeEventsViewer = await EvmStakeEventsViewer.create({
-    contract, logger, context,
-  } satisfies EvmStakeEventsParams)
-  assertEx(await stakeEventsViewer.start(), () => 'Failed to start EvmStakeEvents reader')
-  const stakeChainViewer = await EvmStakeViewer.create({
-    contract, stakeEventsViewer, logger, context,
-  } satisfies EvmStakeViewerParams)
-  assertEx(await stakeChainViewer.start(), () => 'Failed to start EvmStake viewer')
-  return stakeChainViewer
-}
-
-export async function initSimpleStakeViewer(context: CreatableProviderContext, config: Config, logger?: Logger): Promise<StakeViewer> {
-  const stakeViewer = await SimpleStakeViewer.create({
-    context,
-    chainId: asAddress(toAddress(1n), true),
-    logger,
-    positions: [],
-  })
-  assertEx(await stakeViewer.start(), () => 'Failed to start SimpleChainStake viewer')
-  return stakeViewer
-}
-
-export async function initStakeViewer({
-  config, logger, context,
-}: {
-  config: Config
-  context: CreatableProviderContext
-  logger?: Logger
-}): Promise<StakeViewer> {
-  if (canUseEvmProvider({ config })) {
-    return await initEvmChainStakeViewer(context, config, logger)
-  } else {
-    console.warn('[API] Infura configuration not found. Using SimpleChainStakeViewer with no positions. This means no staking data will be available.')
-    return await initSimpleStakeViewer(context, config, logger)
-  }
-}