@xyo-network/chain-orchestration 1.19.13 → 1.19.15

package/src/config/locators/remoteLocatorFromConfig.ts

@@ -0,0 +1,48 @@
+import { assertEx } from '@xylabs/sdk-js'
+import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import {
+  ProviderFactoryLocator,
+  SimpleAccountBalanceViewer,
+  SimpleBlockViewer,
+  SimpleFinalizationViewer,
+  SimpleMempoolRunner,
+  SimpleMempoolViewer,
+  SimpleWindowedBlockViewer,
+  SimpleXyoViewer,
+} from '@xyo-network/xl1-sdk'
+
+import {
+  initActorWallet, initBalanceSummaryMap,
+  initServerNode, initTransferSummaryMap,
+} from '../../init/index.ts'
+
+export async function remoteLocatorFromConfig(
+  context: ActorConfigContext,
+  parent?: ProviderFactoryLocatorInstance,
+): Promise<ProviderFactoryLocatorInstance> {
+  const balancesSummaryMap = assertEx(await initBalanceSummaryMap(context), () => 'Balance Summary Map not initialized')
+  const transfersSummaryMap = assertEx(await initTransferSummaryMap(context), () => 'Transfer Summary Map not initialized')
+
+  // TODO: this should not be an api wallet, but a server wallet
+  const wallet = await initActorWallet(context)
+
+  const {
+    readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist,
+  } = await initServerNode(
+    context,
+    wallet,
+  )
+
+  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
+  locator.registerMany([
+    SimpleMempoolViewer.factory<SimpleMempoolViewer>(SimpleMempoolViewer.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleMempoolRunner.factory<SimpleMempoolRunner>(SimpleMempoolRunner.dependencies, { pendingTransactionsArchivist, pendingBlocksArchivist }),
+    SimpleAccountBalanceViewer.factory<SimpleAccountBalanceViewer>(SimpleAccountBalanceViewer.dependencies, { balancesSummaryMap, transfersSummaryMap }),
+    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleBlockViewer.factory<SimpleBlockViewer>(SimpleBlockViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+    SimpleWindowedBlockViewer.factory<SimpleWindowedBlockViewer>(SimpleWindowedBlockViewer.dependencies, { maxWindowSize: 10_000, syncInterval: 10_000 }),
+    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
+  ])
+  locator.freeze()
+  return locator
+}

package/src/config/locators/rootLocatorFromConfig.ts

@@ -0,0 +1,47 @@
+import { isString } from '@xylabs/sdk-js'
+import { validateHydratedBlock, validateHydratedBlockState } from '@xyo-network/chain-validation'
+import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
+import {
+  ProviderFactoryLocator,
+  SimpleBlockValidationViewer,
+  SimpleNetworkStakeViewer,
+  SimpleStepRewardsByPositionViewer,
+  SimpleStepRewardsByStakerViewer,
+  SimpleStepRewardsByStepViewer,
+  SimpleStepRewardsTotalViewer,
+  SimpleStepRewardsViewer,
+  SimpleStepViewer,
+  SimpleTimeSyncViewer,
+} from '@xyo-network/xl1-sdk'
+
+import { initEvmProvidersIfAvailable } from '../../init/index.ts'
+import { localLocatorFromConfig } from './localLocatorFromConfig.ts'
+import { remoteLocatorFromConfig } from './remoteLocatorFromConfig.ts'
+
+export async function rootLocatorFromConfig(
+  context: ActorConfigContext,
+): Promise<ProviderFactoryLocatorInstance> {
+  const { config } = context
+  let locator: ProviderFactoryLocatorInstance = new ProviderFactoryLocator(context)
+
+  locator.registerMany([
+    SimpleNetworkStakeViewer.factory<SimpleNetworkStakeViewer>(SimpleNetworkStakeViewer.dependencies, {}),
+    SimpleTimeSyncViewer.factory<SimpleTimeSyncViewer>(SimpleTimeSyncViewer.dependencies, {}),
+    SimpleStepViewer.factory<SimpleStepViewer>(SimpleStepViewer.dependencies, {}),
+    SimpleStepRewardsViewer.factory<SimpleStepRewardsViewer>(SimpleStepRewardsViewer.dependencies, {}),
+    SimpleStepRewardsByPositionViewer.factory<SimpleStepRewardsByPositionViewer>(SimpleStepRewardsByPositionViewer.dependencies, {}),
+    SimpleStepRewardsByStakerViewer.factory<SimpleStepRewardsByStakerViewer>(SimpleStepRewardsByStakerViewer.dependencies, {}),
+    SimpleStepRewardsByStepViewer.factory<SimpleStepRewardsByStepViewer>(SimpleStepRewardsByStepViewer.dependencies, {}),
+    SimpleStepRewardsTotalViewer.factory<SimpleStepRewardsTotalViewer>(SimpleStepRewardsTotalViewer.dependencies, {}),
+    SimpleBlockValidationViewer.factory<SimpleBlockValidationViewer>(
+      SimpleBlockValidationViewer.dependencies,
+      { state: validateHydratedBlockState, protocol: validateHydratedBlock },
+    ),
+  ])
+  locator = await initEvmProvidersIfAvailable(locator)
+  locator = await (isString(config.remote.rpc?.url)
+    ? remoteLocatorFromConfig(context, locator)
+    : localLocatorFromConfig(context, locator))
+  locator.freeze()
+  return locator
+}

package/src/config/locators/telemetryContextFromConfig.ts

@@ -0,0 +1,15 @@
+import { initTelemetry } from '@xyo-network/chain-telemetry'
+import type { Config } from '@xyo-network/xl1-sdk'
+
+export async function telemetryContextFromConfig(config: Config, serviceName: string, serviceVersion: string) {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {}
+  const { path: endpoint = '/metrics', port: port = 9466 } = config.telemetry?.metrics?.scrape ?? {}
+  return await initTelemetry({
+    attributes: {
+      serviceName,
+      serviceVersion,
+    },
+    otlpEndpoint,
+    metricsConfig: { endpoint, port },
+  })
+}

package/src/config/mergeConfig.ts

@@ -0,0 +1,11 @@
+import { deepMerge } from '@xylabs/sdk-js'
+import type { Config } from '@xyo-network/xl1-sdk'
+
+export function mergeConfig({ actors, ...baseConfig }: Config) {
+  return {
+    ...baseConfig,
+    actors: actors.map((actor) => {
+      return deepMerge(baseConfig, actor)
+    }),
+  }
+}

package/src/config/tryParseConfig.ts

@@ -0,0 +1,36 @@
+import { isDefined, isNull } from '@xylabs/sdk-js'
+import { ConfigZod } from '@xyo-network/xl1-sdk'
+import { cosmiconfig } from 'cosmiconfig'
+
+/**
+ * The name of the configuration file to search for.
+ */
+const configName = 'xyo'
+
+/**
+ * The name of the section within the configuration file to parse.
+ */
+const configSection = 'xl1' // Default section in the config file
+
+/**
+ * Attempts to parse the configuration from a file using cosmiconfig.
+ * @returns The parsed configuration object if found and valid, otherwise undefined.
+ */
+export async function tryParseConfig(searchPlaces?: string[]) {
+  const explorer = cosmiconfig(
+    configName,
+    {
+      cache: true,
+      // loaders: { '.ts': TypeScriptLoader() },
+      searchPlaces,
+    },
+  )
+  const result = (await explorer.search())?.config
+  if (!isNull(result)) {
+    const section = result[configSection]
+    if (isDefined(section) && typeof section === 'object') {
+      return ConfigZod.loose().parse(section)
+    }
+  }
+  return ConfigZod.parse({})
+}

package/src/evm/initChainId.ts

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

package/src/evm/initEvmProvider.ts

@@ -1,6 +1,5 @@
-import type { Logger } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-sdk'
+import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
 import type { Provider } from 'ethers'
 
 import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
@@ -8,16 +7,16 @@ import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvide
 
 let provider: Promise<Provider> | undefined
 
-export const initEvmProvider = async ({ config }: { config: Config; logger?: Logger }): Promise<Provider> => {
+export const initEvmProvider = async (context: BaseConfigContext): Promise<Provider> => {
   if (provider) return provider
-  if (canUseInfuraProvider(config)) {
-    provider = initInfuraProvider(config)
-  } else if (canUseJsonRpcProvider(config)) {
-    provider = initJsonRpcProvider(config)
+  if (canUseInfuraProvider(context)) {
+    provider = initInfuraProvider(context)
+  } else if (canUseJsonRpcProvider(context)) {
+    provider = initJsonRpcProvider(context)
   }
   return assertEx(await provider, () => 'No provider available')
 }
 
-export const canUseEvmProvider = ({ config }: { config: Config }) => {
-  return canUseInfuraProvider(config) || canUseJsonRpcProvider(config)
+export const canUseEvmProvider = (context: BaseConfigContext) => {
+  return canUseInfuraProvider(context) || canUseJsonRpcProvider(context)
 }

package/src/evm/initInfuraProvider.ts

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

package/src/evm/initJsonRpcProvider.ts

@@ -1,20 +1,22 @@
 import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { Config } from '@xyo-network/xl1-sdk'
+import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
 import { JsonRpcProvider } from 'ethers/providers'
 
 import { canUseChainId, getChainId } from './initChainId.ts'
 
-export const initJsonRpcProvider = (config: Config) => {
-  const providerConfig = getJsonRpcProviderConfig(config)
+export const initJsonRpcProvider = (context: BaseConfigContext) => {
+  const providerConfig = getJsonRpcProviderConfig(context)
   return Promise.resolve(new JsonRpcProvider(...providerConfig))
 }
 
-export const canUseJsonRpcProvider = (config: Config) => {
-  return canUseChainId(config)
+export const canUseJsonRpcProvider = (context: BaseConfigContext) => {
+  const { config } = context
+  return canUseChainId(context)
     && isDefined(config.evm.jsonRpc?.url)
 }
 
-export const getJsonRpcProviderConfig = (config: Config) => {
+export const getJsonRpcProviderConfig = (context: BaseConfigContext) => {
+  const { config } = context
   const jsonRpcUrl = assertEx(config.evm.jsonRpc?.url, () => 'Missing config.evm.jsonRpc.url')
-  return [jsonRpcUrl, getChainId(config)] as const
+  return [jsonRpcUrl, getChainId(context)] as const
 }

package/src/health/initHealthEndpoints.ts

@@ -1,13 +1,9 @@
-import type {
-  IncomingMessage, Server, ServerResponse,
-} from 'node:http'
+import type { IncomingMessage, ServerResponse } from 'node:http'
 import http from 'node:http'
 
-import type { CreatableStatus, Logger } from '@xylabs/sdk-js'
+import type { CreatableStatus } from '@xylabs/sdk-js'
 import { isDefined } from '@xylabs/sdk-js'
-import type {
-  Config, Initializable, RuntimeStatusMonitor,
-} from '@xyo-network/xl1-sdk'
+import type { ActorConfigContext, RuntimeStatusMonitor } from '@xyo-network/xl1-sdk'
 
 const sendStatus = (res: ServerResponse, status: CreatableStatus, errorCode: number) => {
   const statusCode = status === 'started' ? 200 : errorCode
@@ -25,9 +21,12 @@ const notFound = (res: ServerResponse) => {
  * - /healthz
  * - /livez
  * - /readyz
+ * @param context The actor configuration context
  * @param port The port to listen on (default: 8080)
+ * @param statusMonitor The runtime status monitor to determine the health status
  */
-const createHealthServer = (port: number, statusMonitor: RuntimeStatusMonitor, logger: Logger) => {
+const createHealthServer = (context: ActorConfigContext, port: number, statusMonitor: RuntimeStatusMonitor) => {
+  const { logger } = context
   const server = http.createServer((req: IncomingMessage, res: ServerResponse) => {
     const url = req.url ?? ''
 
@@ -53,18 +52,16 @@ const createHealthServer = (port: number, statusMonitor: RuntimeStatusMonitor, l
   })
 
   server.listen(port, () => {
-    logger.log(`Health server running on http://localhost:${port}`)
-    logger.log(' - /healthz')
-    logger.log(' - /livez')
-    logger.log(' - /readyz')
+    logger?.log(`Health server running on http://localhost:${port}`)
+    logger?.log(' - /healthz')
+    logger?.log(' - /livez')
+    logger?.log(' - /readyz')
   })
   return server
 }
 
-export const initHealthEndpoints: Initializable<{ config: Config; logger: Logger; statusReporter: RuntimeStatusMonitor }, Server | undefined> = (params) => {
-  const {
-    config, logger, statusReporter,
-  } = params
-  const { healthCheckPort } = config.actors.producer
-  return isDefined(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : undefined
+export function initHealthEndpoints(context: ActorConfigContext, statusMonitor: RuntimeStatusMonitor) {
+  const { config } = context
+  const { healthCheckPort } = config
+  return isDefined(healthCheckPort) ? createHealthServer(context, healthCheckPort, statusMonitor) : undefined
 }

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './actor/index.ts'
 export * from './archivists/index.ts'
 export * from './buildTelemetryConfig.ts'
 export * from './ChainInitializableParams.ts'
+export * from './config/index.ts'
 export * from './createDeclarationIntentBlock.ts'
 export * from './evm/index.ts'
 export * from './health/index.ts'

package/src/init/index.ts

@@ -1,10 +1,10 @@
+export * from './initActorAccount.ts'
+export * from './initActorSeedPhrase.ts'
 export * from './initBalanceSummaryMap.ts'
 export * from './initBridgedModule.ts'
 export * from './initEvmProvidersIfAvailable.ts'
 export * from './initFinalizationArchivistIfNeeded.ts'
 export * from './initFinalizedArchivist.ts'
-export * from './initProducerAccount.ts'
-export * from './initSeedPhrase.ts'
 export * from './initServerNode.ts'
 export * from './initStatusReporter.ts'
 export * from './initTransferSummaryMap.ts'

package/src/init/initActorAccount.ts

@@ -0,0 +1,28 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import { isDefined, isUndefined } from '@xylabs/sdk-js'
+import { HDWallet } from '@xyo-network/wallet'
+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/init/{initSeedPhrase.ts → initActorSeedPhrase.ts}

@@ -1,19 +1,19 @@
 import { assertEx, isString } from '@xylabs/sdk-js'
 import type { BiosExternalInterface } from '@xyo-network/bios-model'
+import type { WalletKind } from '@xyo-network/storage-model'
 import { HDWallet } from '@xyo-network/wallet'
-
-import type { ConfigContext } from '../ConfigContext.ts'
+import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
 
 // TODO: Make nodejs version of bios support round tripping mnemonic between boots
-export async function initSeedPhrase({
-  config, logger, bios,
-}: ConfigContext<{ bios: BiosExternalInterface }>): Promise<string> {
-  const storedSeedPhrase = await bios.seedPhraseStore.get('os')
+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.actors.api
+  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('os', mnemonic)
+    await bios.seedPhraseStore.set(walletKind, mnemonic)
   } else {
     let seedPhrase: string
     if (isString(mnemonic)) {
@@ -23,7 +23,7 @@ export async function initSeedPhrase({
       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('os', seedPhrase)
+    await bios.seedPhraseStore.set(walletKind, seedPhrase)
   }
-  return assertEx(await bios.seedPhraseStore.get('os'), () => 'Unable to acquire mnemonic from bios')
+  return assertEx(await bios.seedPhraseStore.get(walletKind), () => 'Unable to acquire mnemonic from bios')
 }

package/src/init/initBalanceSummaryMap.ts

@@ -3,12 +3,12 @@ import type { Hash } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
 import { MongoMap } from '@xyo-network/chain-protocol'
 import type { WithStorageMeta } from '@xyo-network/payload-model'
-import type { BalancesStepSummary, MapType } from '@xyo-network/xl1-sdk'
+import type {
+  BalancesStepSummary, BaseConfigContext, MapType,
+} from '@xyo-network/xl1-sdk'
 import { hasMongoConfig, MemoryMap } from '@xyo-network/xl1-sdk'
 
-import type { ConfigContext } from '../ConfigContext.ts'
-
-export async function initBalanceSummaryMap({ config, logger }: ConfigContext): Promise<MapType<string, WithStorageMeta<BalancesStepSummary>>> {
+export async function initBalanceSummaryMap({ logger, config }: BaseConfigContext): Promise<MapType<string, WithStorageMeta<BalancesStepSummary>>> {
   const mongoConfig = config.storage?.mongo
   if (hasMongoConfig(mongoConfig)) {
     // Create the MongoDB SDK from the configuration

package/src/init/initBridgedModule.ts

@@ -1,11 +1,10 @@
-import type { Address, Logger } from '@xylabs/sdk-js'
+import type { Address } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
 import type { AttachableArchivistInstance } from '@xyo-network/archivist-model'
 import { asAttachableArchivistInstance } from '@xyo-network/archivist-model'
 import type { BridgeInstance } from '@xyo-network/bridge-model'
 import type { AttachableModuleInstance, ModuleIdentifier } from '@xyo-network/module-model'
 import { asAttachableModuleInstance } from '@xyo-network/module-model'
-import type { Initializable } from '@xyo-network/xl1-sdk'
 import { Mutex } from 'async-mutex'
 
 const initMutex = new Mutex()
@@ -13,9 +12,7 @@ type ModuleDictionary = Record<ModuleIdentifier, AttachableModuleInstance | unde
 type BridgedModuleDictionary = Record<Address, ModuleDictionary | undefined>
 const bridgedModuleDictionary: BridgedModuleDictionary = {}
 
-export const initBridgedModule: Initializable<
-  { bridge: BridgeInstance; moduleName: ModuleIdentifier }, AttachableModuleInstance
-> = async ({ bridge, moduleName }): Promise<AttachableModuleInstance> => {
+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
@@ -33,9 +30,10 @@ export const initBridgedModule: Initializable<
   })
 }
 
-export const initBridgedArchivistModule: Initializable<
-  { bridge: BridgeInstance; logger?: Logger; moduleName: ModuleIdentifier }, AttachableArchivistInstance
-> = async ({ bridge, moduleName }): Promise<AttachableArchivistInstance> => {
+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/init/initEvmProvidersIfAvailable.ts

@@ -16,10 +16,11 @@ import {
 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 context = locator.context
+  const { logger, config } = context
+  if (canUseEvmProvider(context)) {
+    const chainId = assertEx(context.config.chain.id as ChainId, () => 'Missing config.chain.id (required for EVM providers)')
+    const provider = await initEvmProvider(context)
     const address = asEthAddress(chainId, true)
 
     // Register the contract events viewer
@@ -53,7 +54,7 @@ export async function initEvmProvidersIfAvailable(locator: ProviderFactoryLocato
   } 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)')
+    const chainId = assertEx(config.chain.id, () => 'Missing config.chain.id (required for non-EVM providers)')
 
     // Register the contract events viewer
     locator.register(SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(

package/src/init/initFinalizationArchivistIfNeeded.ts

@@ -1,18 +1,21 @@
 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 { Account } from '@xyo-network/sdk-js'
+import type {
+  ActorConfig,
+  ChainId,
+  SignedBlockBoundWitnessWithHashMeta,
+} from '@xyo-network/xl1-sdk'
 import {
-  asAttoXL1,
-  type ChainId, type Config, findMostRecentBlock,
+  asAttoXL1, findMostRecentBlock,
   flattenHydratedBlock,
-  type SignedBlockBoundWitnessWithHashMeta,
 } from '@xyo-network/xl1-sdk'
 
 export async function initFinalizationArchivistIfNeeded(
   archivist: ArchivistInstance,
-  config: Config,
+  config: ActorConfig,
   account: AccountInstance,
 ): Promise<[SignedBlockBoundWitnessWithHashMeta, ChainId]> {
   const configuredChainId = config.chain.id

package/src/init/initServerNode.ts

@@ -1,13 +1,9 @@
 import { assertEx } from '@xylabs/sdk-js'
 import { asArchivistInstance } from '@xyo-network/archivist-model'
 import type { NodeInstance } from '@xyo-network/node-model'
-import type { WithStorageMeta } from '@xyo-network/payload-model'
 import type { WalletInstance } from '@xyo-network/wallet-model'
-import type {
-  BalancesStepSummary, MapType, TransfersStepSummary,
-} from '@xyo-network/xl1-sdk'
+import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
 
-import type { ConfigContext } from '../ConfigContext.ts'
 import { loadNode } from '../manifest/index.ts'
 
 async function writableChainArchivistFromNode(node: NodeInstance) {
@@ -38,17 +34,12 @@ async function pendingBlocksArchivistFromNode(node: NodeInstance) {
   )
 }
 
-export async function initServerNode({
-  wallet, logger, config, node: providedNode, transfersSummaryMap, balancesSummaryMap,
-}: ConfigContext<{
-  balancesSummaryMap: MapType<string, WithStorageMeta<BalancesStepSummary>>
-  node?: NodeInstance
-  transfersSummaryMap: MapType<string, WithStorageMeta<TransfersStepSummary>>
-  wallet: WalletInstance
-}>) {
-  const node: NodeInstance = providedNode ?? await loadNode({
-    wallet, logger, config, transfersSummaryMap, balancesSummaryMap,
-  })
+export async function initServerNode(
+  context: BaseConfigContext,
+  wallet: WalletInstance,
+  providedNode?: NodeInstance,
+) {
+  const node: NodeInstance = providedNode ?? await loadNode(context, wallet)
   assertEx(await node.start(), () => 'Failed to start node')
   const writableChainArchivist = await writableChainArchivistFromNode(node)
   const readonlyChainArchivist = await readonlyChainArchivistFromNode(node)

package/src/init/initTransferSummaryMap.ts

@@ -3,12 +3,12 @@ import type { Hash } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
 import { MongoMap } from '@xyo-network/chain-protocol'
 import type { WithStorageMeta } from '@xyo-network/payload-model'
-import type { MapType, TransfersStepSummary } from '@xyo-network/xl1-sdk'
+import type {
+  BaseConfigContext, MapType, TransfersStepSummary,
+} from '@xyo-network/xl1-sdk'
 import { hasMongoConfig, MemoryMap } from '@xyo-network/xl1-sdk'
 
-import type { ConfigContext } from '../ConfigContext.ts'
-
-export async function initTransferSummaryMap({ config, logger }: ConfigContext): Promise<MapType<string, WithStorageMeta<TransfersStepSummary>>> {
+export async function initTransferSummaryMap({ logger, config }: BaseConfigContext): Promise<MapType<string, WithStorageMeta<TransfersStepSummary>>> {
   const mongoConfig = config.storage?.mongo
   if (hasMongoConfig(mongoConfig)) {
     // Create the MongoDB SDK from the configuration