@xyo-network/chain-orchestration 1.20.14 → 1.20.16

package/src/node/config/locators/actors/bridgeLocatorFromConfig.ts

@@ -1,83 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import { isDefined } from '@xylabs/sdk-js'
-import { HDWallet } from '@xyo-network/sdk-js'
-import type { ProviderFactoryLocatorInstance, RestDataLakeRunnerParams } from '@xyo-network/xl1-sdk'
-import {
-  ADDRESS_INDEX,
-  generateXyoBaseWalletFromPhrase,
-  JsonRpcAccountBalanceViewer,
-  JsonRpcBlockViewer,
-  JsonRpcFinalizationViewer,
-  JsonRpcMempoolRunner,
-  JsonRpcMempoolViewer,
-  JsonRpcXyoRunner,
-  JsonRpcXyoViewer,
-  ProviderFactoryLocator,
-  RestDataLakeRunner,
-  RestDataLakeViewer,
-  SimpleStakeEventsViewer,
-  SimpleXyoConnectionRunner,
-  SimpleXyoGatewayRunner,
-  SimpleXyoRunner,
-  SimpleXyoSigner,
-} from '@xyo-network/xl1-sdk'
-
-import type { BridgeConfigContext } from '../../../../neutral/index.ts'
-
-export async function bridgeLocatorFromConfig(
-  context: BridgeConfigContext,
-  parent?: ProviderFactoryLocatorInstance,
-): Promise<Promise<Promisable<ProviderFactoryLocatorInstance>>> {
-  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
-
-  const { config } = context
-
-  const { dataLake, mnemonic } = config
-  const walletPhrase = isDefined(mnemonic) ? mnemonic : HDWallet.generateMnemonic()
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase)
-  const signerAccount = await wallet.derivePath(ADDRESS_INDEX.XYO)
-
-  if (config.remote.rpc) {
-    locator.registerMany([
-      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, {}),
-      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, {}),
-      JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
-        JsonRpcAccountBalanceViewer.dependencies,
-        {},
-      ),
-      JsonRpcFinalizationViewer.factory<JsonRpcFinalizationViewer>(
-        JsonRpcFinalizationViewer.dependencies,
-        {},
-      ),
-      JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, {}),
-      JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
-      JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, {}),
-    ])
-  }
-  if (isDefined(dataLake)) {
-    const { driver } = dataLake
-    switch (driver) {
-      case 'rest': {
-        const { url: endpoint } = dataLake
-        locator.registerMany([
-          RestDataLakeRunner.factory<RestDataLakeRunner<RestDataLakeRunnerParams>>(RestDataLakeRunner.dependencies, { endpoint }),
-          RestDataLakeViewer.factory<RestDataLakeViewer>(RestDataLakeViewer.dependencies, { endpoint }),
-        ])
-        break
-      }
-      default: {
-        throw new Error(`Unsupported data lake protocol: ${driver}`)
-      }
-    }
-  }
-
-  locator.registerMany([
-    SimpleStakeEventsViewer.factory<SimpleStakeEventsViewer>(SimpleStakeEventsViewer.dependencies, { positions: [] }),
-    SimpleXyoSigner.factory<SimpleXyoSigner>(SimpleXyoSigner.dependencies, { account: signerAccount }),
-    SimpleXyoRunner.factory<SimpleXyoRunner>(SimpleXyoRunner.dependencies, {}),
-    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
-    SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
-  ])
-  locator.freeze()
-  return locator
-}

package/src/node/config/locators/actors/index.ts

@@ -1,6 +0,0 @@
-export * from './apiLocatorFromConfig.ts'
-export * from './bridgeLocatorFromConfig.ts'
-export * from './mempoolLocatorFromConfig.ts'
-export * from './producerLocatorFromConfig.ts'
-export * from './rewardRedemptionLocatorFromConfig.ts'
-export * from './validatorLocatorFromConfig.ts'

package/src/node/config/locators/actors/mempoolLocatorFromConfig.ts

@@ -1,17 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-import { ProviderFactoryLocator } from '@xyo-network/xl1-sdk'
-
-import type { MempoolConfigContext } from '../../../../neutral/index.ts'
-
-export function mempoolLocatorFromConfig(
-  context: MempoolConfigContext,
-  parent?: ProviderFactoryLocatorInstance,
-): Promisable<ProviderFactoryLocatorInstance> {
-  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
-
-  locator.registerMany([
-  ])
-  locator.freeze()
-  return locator
-}

package/src/node/config/locators/actors/producerLocatorFromConfig.ts

@@ -1,29 +0,0 @@
-import { asAddress } from '@xylabs/sdk-js'
-import { SimpleBlockRunner } from '@xyo-network/chain-services'
-import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-import { ProviderFactoryLocator } from '@xyo-network/xl1-sdk'
-
-import type { ProducerConfigContext } from '../../../../neutral/index.ts'
-import { initActorAccount } from '../../../../neutral/index.ts'
-
-export async function producerLocatorFromConfig(
-  context: ProducerConfigContext,
-  parent?: ProviderFactoryLocatorInstance,
-): Promise<ProviderFactoryLocatorInstance> {
-  const { logger, config } = context
-  const account = await initActorAccount(context)
-  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
-  const rewardAddress = asAddress(config.rewardAddress ?? account.address, true)
-  logger?.info(`Using reward address ${rewardAddress}`)
-  if (rewardAddress === account.address) {
-    logger?.warn(`Using producer account address as reward address: ${account.address}`)
-  }
-
-  locator.registerMany([
-    SimpleBlockRunner.factory<SimpleBlockRunner>(
-      SimpleBlockRunner.dependencies,
-      { account, rewardAddress },
-    )])
-  locator.freeze()
-  return locator
-}

package/src/node/config/locators/actors/rewardRedemptionLocatorFromConfig.ts

@@ -1,56 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-import {
-  JsonRpcAccountBalanceViewer,
-  JsonRpcBlockViewer,
-  JsonRpcFinalizationViewer,
-  JsonRpcMempoolRunner,
-  JsonRpcMempoolViewer,
-  JsonRpcXyoRunner,
-  JsonRpcXyoViewer,
-  ProviderFactoryLocator,
-  SimpleXyoConnectionRunner,
-  SimpleXyoGatewayRunner,
-  SimpleXyoRunner,
-  SimpleXyoSigner,
-} from '@xyo-network/xl1-sdk'
-
-import { initActorAccount, type RewardRedemptionConfigContext } from '../../../../neutral/index.ts'
-
-export async function rewardRedemptionLocatorFromConfig(
-  context: RewardRedemptionConfigContext,
-  parent?: ProviderFactoryLocatorInstance,
-): Promise<Promisable<ProviderFactoryLocatorInstance>> {
-  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
-
-  const { config } = context
-
-  const account = await initActorAccount(context)
-
-  if (config.remote.rpc) {
-    locator.registerMany([
-      JsonRpcMempoolViewer.factory<JsonRpcMempoolViewer>(JsonRpcMempoolViewer.dependencies, {}),
-      JsonRpcMempoolRunner.factory<JsonRpcMempoolRunner>(JsonRpcMempoolRunner.dependencies, {}),
-      JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
-        JsonRpcAccountBalanceViewer.dependencies,
-        {},
-      ),
-      JsonRpcFinalizationViewer.factory<JsonRpcFinalizationViewer>(
-        JsonRpcFinalizationViewer.dependencies,
-        {},
-      ),
-      JsonRpcBlockViewer.factory<JsonRpcBlockViewer>(JsonRpcBlockViewer.dependencies, {}),
-      JsonRpcXyoRunner.factory<JsonRpcXyoRunner>(JsonRpcXyoRunner.dependencies, {}),
-      JsonRpcXyoViewer.factory<JsonRpcXyoViewer>(JsonRpcXyoViewer.dependencies, {}),
-    ])
-  }
-
-  locator.registerMany([
-    SimpleXyoSigner.factory<SimpleXyoSigner>(SimpleXyoSigner.dependencies, { account }),
-    SimpleXyoRunner.factory<SimpleXyoRunner>(SimpleXyoRunner.dependencies, {}),
-    SimpleXyoConnectionRunner.factory<SimpleXyoConnectionRunner>(SimpleXyoConnectionRunner.dependencies, {}),
-    SimpleXyoGatewayRunner.factory<SimpleXyoGatewayRunner>(SimpleXyoGatewayRunner.dependencies, {}),
-  ])
-  locator.freeze()
-  return locator
-}

package/src/node/config/locators/actors/validatorLocatorFromConfig.ts

@@ -1,15 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-import { ProviderFactoryLocator } from '@xyo-network/xl1-sdk'
-
-export function validatorLocatorFromConfig(
-  context: ActorConfigContext,
-  parent?: ProviderFactoryLocatorInstance,
-): Promisable<ProviderFactoryLocatorInstance> {
-  const locator = new ProviderFactoryLocator({ ...context, locator: parent })
-
-  locator.registerMany([
-  ])
-  locator.freeze()
-  return locator
-}

package/src/node/config/locators/basicRemoteRunnerLocator.ts

@@ -1,38 +0,0 @@
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import { isAccountInstance } from '@xyo-network/sdk-js'
-import type {
-  RemoteConfig, RpcTransport, XyoSignerRpcSchemas,
-} from '@xyo-network/xl1-sdk'
-import {
-  JsonRpcAccountBalanceViewer,
-  JsonRpcXyoSigner,
-  SimpleXyoSigner,
-} from '@xyo-network/xl1-sdk'
-
-import { baseBasicRemoteRunnerLocator } from '../../../shared/index.ts'
-
-function signerFactoryFromParam(signer: RpcTransport<XyoSignerRpcSchemas> | AccountInstance) {
-  if (isAccountInstance(signer)) {
-    return SimpleXyoSigner.factory<SimpleXyoSigner>(SimpleXyoSigner.dependencies, { account: signer })
-  }
-  return JsonRpcXyoSigner.factory<JsonRpcXyoSigner>(JsonRpcXyoSigner.dependencies, { transport: signer })
-}
-
-export function basicRemoteRunnerLocator(
-  name: string,
-  remoteConfig: RemoteConfig,
-  signer: RpcTransport<XyoSignerRpcSchemas> | AccountInstance,
-  dataLakeEndpoint?: string,
-) {
-  const transport = isAccountInstance(signer) ? undefined as never : signer
-  return baseBasicRemoteRunnerLocator(name, remoteConfig, transport, dataLakeEndpoint, {
-    additionalProviders: [
-      JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
-        JsonRpcAccountBalanceViewer.dependencies,
-        {},
-      ),
-    ],
-    signerFactory: signerFactoryFromParam(signer),
-    skipGatewayRunner: true,
-  })
-}

package/src/node/config/locators/basicRemoteViewerLocator.ts

@@ -1,19 +0,0 @@
-import type { RemoteConfig } from '@xyo-network/xl1-sdk'
-import { JsonRpcAccountBalanceViewer } from '@xyo-network/xl1-sdk'
-
-import { baseBasicRemoteViewerLocator } from '../../../shared/index.ts'
-
-export function basicRemoteViewerLocator(
-  name: string,
-  remoteConfig: RemoteConfig,
-  dataLakeEndpoint?: string,
-) {
-  return baseBasicRemoteViewerLocator(name, remoteConfig, dataLakeEndpoint, {
-    additionalProviders: [
-      JsonRpcAccountBalanceViewer.factory<JsonRpcAccountBalanceViewer>(
-        JsonRpcAccountBalanceViewer.dependencies,
-        {},
-      ),
-    ],
-  })
-}

package/src/node/config/locators/contextFromConfigWithoutLocator.ts

@@ -1,25 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-import type { Config, CreatableProviderContext } from '@xyo-network/xl1-sdk'
-
-import { initStatusReporter } from '../../../shared/index.ts'
-import { telemetryContextFromConfig } from './telemetryContextFromConfig.ts'
-
-export async function contextFromConfigWithoutLocator(
-  config: Config,
-  logger: Logger,
-  serviceName: string,
-  serviceVersion: string,
-): Promise<Omit<CreatableProviderContext, 'locator'>> {
-  const singletons = {}
-  const caches = {}
-  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion)
-  const statusReporter = initStatusReporter({ logger })
-  return {
-    ...telemetryConfig,
-    config,
-    singletons,
-    caches,
-    logger,
-    statusReporter,
-  }
-}

package/src/node/config/locators/index.ts

@@ -1,7 +0,0 @@
-export * from './basicRemoteRunnerLocator.ts'
-export * from './basicRemoteViewerLocator.ts'
-export * from './contextFromConfigWithoutLocator.ts'
-export * from './localLocatorFromConfig.ts'
-export * from './locatorsFromConfig.ts'
-export * from './rootLocatorFromConfig.ts'
-export * from './telemetryContextFromConfig.ts'

package/src/node/config/locators/localLocatorFromConfig.ts

@@ -1,75 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { validateHydratedBlock, validateHydratedBlockState } from '@xyo-network/chain-validation'
-import type { ActorConfigContext, HydratedBlockStateValidationFunction } from '@xyo-network/xl1-sdk'
-import {
-  BlockCumulativeBalanceValidatorFactory,
-  ProviderFactoryLocator,
-  SimpleAccountBalanceViewer,
-  SimpleBlockValidationViewer,
-  SimpleBlockViewer,
-  SimpleFinalizationRunner,
-  SimpleFinalizationViewer,
-  SimpleMempoolRunner,
-  SimpleMempoolViewer,
-  SimpleTransactionViewer,
-  SimpleWindowedBlockViewer,
-  SimpleXyoConnectionViewer,
-  SimpleXyoViewer,
-} from '@xyo-network/xl1-sdk'
-
-import { initActorWallet } from '../../../shared/index.ts'
-import {
-  initBalanceSummaryMap, initFinalizationArchivistIfNeeded,
-  initServerNode, initTransferSummaryMap,
-} from '../../init/index.ts'
-
-const cumulativeBalanceValidator = BlockCumulativeBalanceValidatorFactory()
-
-const validateHydratedBlockStateWithCumulativeBalance: HydratedBlockStateValidationFunction = async (context, block) => {
-  const [stateErrors, cumulativeErrors] = await Promise.all([
-    validateHydratedBlockState(context, block),
-    cumulativeBalanceValidator(context, block),
-  ])
-  return [...stateErrors, ...cumulativeErrors]
-}
-
-export async function localLocatorFromConfig(
-  context: ActorConfigContext,
-  validateDepsOnRegister = false,
-) {
-  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 {
-    writableChainArchivist, readonlyChainArchivist, pendingTransactionsArchivist, pendingBlocksArchivist,
-  } = await initServerNode(
-    context,
-    wallet,
-  )
-
-  await initFinalizationArchivistIfNeeded(writableChainArchivist, context.config, wallet)
-
-  const locator = new ProviderFactoryLocator(context, {}, validateDepsOnRegister)
-  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: 1000, syncInterval: 10_000 }),
-    SimpleXyoConnectionViewer.factory<SimpleXyoConnectionViewer>(SimpleXyoConnectionViewer.dependencies, {}),
-    SimpleTransactionViewer.factory<SimpleTransactionViewer>(SimpleTransactionViewer.dependencies, {}),
-    SimpleXyoViewer.factory<SimpleXyoViewer>(SimpleXyoViewer.dependencies, {}),
-    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist: readonlyChainArchivist }),
-    SimpleFinalizationRunner.factory<SimpleFinalizationRunner>(SimpleFinalizationRunner.dependencies, { finalizedArchivist: writableChainArchivist }),
-    SimpleBlockValidationViewer.factory<SimpleBlockValidationViewer>(
-      SimpleBlockValidationViewer.dependencies,
-      { state: validateHydratedBlockStateWithCumulativeBalance, protocol: validateHydratedBlock },
-    ),
-
-  ])
-  return locator
-}

package/src/node/config/locators/localViewerFromConfig.ts

@@ -1,14 +0,0 @@
-import type { ActorConfigContext } from '@xyo-network/xl1-sdk'
-import { XyoViewerMoniker } from '@xyo-network/xl1-sdk'
-
-import { commonLocatorFromConfig } from '../../../shared/index.ts'
-import { localLocatorFromConfig } from './localLocatorFromConfig.ts'
-
-export async function localViewerFromConfig(
-  context: ActorConfigContext,
-) {
-  const commonLocator = await commonLocatorFromConfig(context)
-  const locator = await localLocatorFromConfig({ ...commonLocator.context, config: { ...commonLocator.context.config, ...context.config } }, true)
-  locator.freeze()
-  return locator.getInstance(XyoViewerMoniker)
-}

package/src/node/config/locators/locatorsFromConfig.ts

@@ -1,75 +0,0 @@
-import { deepMerge } from '@xylabs/sdk-js'
-import {
-  ActorConfigZod,
-  type CachingContext,
-  type Config, type ProviderFactoryLocatorInstance,
-} from '@xyo-network/xl1-sdk'
-
-import {
-  ApiConfigZod, BridgeConfigZod, MempoolConfigZod, ProducerConfigZod, RewardRedemptionConfigZod,
-} from '../../../shared/index.ts'
-import {
-  apiLocatorFromConfig, bridgeLocatorFromConfig, mempoolLocatorFromConfig,
-  producerLocatorFromConfig, rewardRedemptionLocatorFromConfig, validatorLocatorFromConfig,
-} from './actors/index.ts'
-import { rootLocatorFromConfig } from './rootLocatorFromConfig.ts'
-
-export async function locatorsFromConfig(
-  context: CachingContext,
-  { actors, ...config }: Config,
-): Promise<Record<string, ProviderFactoryLocatorInstance>> {
-  const result: Record<string, ProviderFactoryLocatorInstance> = { _root: await rootLocatorFromConfig({ ...context, config: { ...config, name: '_root' } }) }
-  for (const actorConfig of actors) {
-    switch (actorConfig.name) {
-      case 'producer': {
-        result[actorConfig.name] = await producerLocatorFromConfig(
-          { ...context, config: ProducerConfigZod.parse(deepMerge(config, actorConfig)) },
-          result._root,
-        )
-        break
-      }
-      case 'api': {
-        result[actorConfig.name] = await apiLocatorFromConfig(
-          { ...context, config: ApiConfigZod.parse(deepMerge(config, actorConfig)) },
-          result._root,
-        )
-
-        break
-      }
-      case 'mempool': {
-        result[actorConfig.name] = await mempoolLocatorFromConfig(
-          { ...context, config: MempoolConfigZod.parse(deepMerge(config, actorConfig)) },
-          result._root,
-        )
-        break
-      }
-      case 'validator': {
-        result[actorConfig.name] = await validatorLocatorFromConfig(
-          { ...context, config: ActorConfigZod.parse(deepMerge(config, actorConfig)) },
-          result._root,
-        )
-        break
-      }
-      case 'bridge': {
-        result[actorConfig.name] = await bridgeLocatorFromConfig(
-          { ...context, config: BridgeConfigZod.parse(deepMerge(config, actorConfig)) },
-          result._root,
-        )
-
-        break
-      }
-      case 'rewardRedemption': {
-        result[actorConfig.name] = await rewardRedemptionLocatorFromConfig(
-          {
-            ...context,
-            config: RewardRedemptionConfigZod.parse(deepMerge(config, actorConfig)),
-          },
-          result._root,
-        )
-        break
-      }
-    // No default
-    }
-  }
-  return result
-}

package/src/node/config/locators/remoteViewerFromConfig.ts

@@ -1,13 +0,0 @@
-import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
-import { XyoViewerMoniker } from '@xyo-network/xl1-sdk'
-
-import { commonLocatorFromConfig, remoteLocatorFromConfig } from '../../../shared/index.ts'
-
-export async function remoteViewerFromConfig(
-  context: BaseConfigContext,
-) {
-  const commonLocator = await commonLocatorFromConfig(context)
-  const locator = await remoteLocatorFromConfig(commonLocator.context)
-  locator.freeze()
-  return locator.getInstance(XyoViewerMoniker)
-}

package/src/node/config/locators/rootLocatorFromConfig.ts

@@ -1,22 +0,0 @@
-import type { ActorConfigContext, ProviderFactoryLocatorInstance } from '@xyo-network/xl1-sdk'
-
-import {
-  commonLocatorFromConfig, initEvmProvidersIfAvailable, remoteLocatorFromConfig,
-} from '../../index.ts'
-import { localLocatorFromConfig } from './localLocatorFromConfig.ts'
-
-export async function rootLocatorFromConfig(
-  context: ActorConfigContext,
-  validateDepsOnRegister = false,
-): Promise<ProviderFactoryLocatorInstance> {
-  const { config } = context
-  let locator = await commonLocatorFromConfig(context, validateDepsOnRegister)
-
-  const newLocator = await (config.remote.rpc
-    ? remoteLocatorFromConfig(locator.context, validateDepsOnRegister)
-    : localLocatorFromConfig({ ...locator.context, config: { ...locator.context.config, ...context.config } }, validateDepsOnRegister))
-  locator = newLocator
-  locator = await initEvmProvidersIfAvailable(locator)
-  locator.freeze()
-  return locator
-}

package/src/node/config/locators/telemetryContextFromConfig.ts

@@ -1,15 +0,0 @@
-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/node/config/tryParseConfig.ts

@@ -1,42 +0,0 @@
-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.
- * @param options - Optional config loading options.
- * @param options.configPath - Explicit path to a config file to load instead of searching.
- * @param options.searchPlaces - Custom search places for cosmiconfig.
- * @returns The parsed configuration object if found and valid, otherwise undefined.
- */
-export async function tryParseConfig(options?: { configPath?: string; searchPlaces?: string[] }) {
-  const { configPath, searchPlaces } = options ?? {}
-  const explorer = cosmiconfig(
-    configName,
-    {
-      cache: true,
-      // loaders: { '.ts': TypeScriptLoader() },
-      searchPlaces,
-    },
-  )
-  const result = isDefined(configPath)
-    ? (await explorer.load(configPath))?.config
-    : (await explorer.search())?.config
-  if (isDefined(result) && !isNull(result)) {
-    const section = result[configSection]
-    if (isDefined(section) && typeof section === 'object') {
-      return ConfigZod.loose().parse(section)
-    }
-  }
-  return ConfigZod.parse({})
-}

package/src/node/evm/index.ts

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

package/src/node/evm/initChainId.ts

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

package/src/node/evm/initEvmProvider.ts

@@ -1,22 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { BaseConfigContext } from '@xyo-network/xl1-sdk'
-import type { Provider } from 'ethers'
-
-import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
-import { canUseJsonRpcProvider, initJsonRpcProvider } from './initJsonRpcProvider.ts'
-
-let provider: Promise<Provider> | undefined
-
-export const initEvmProvider = async (context: BaseConfigContext): Promise<Provider> => {
-  if (provider) return provider
-  if (canUseInfuraProvider(context)) {
-    provider = initInfuraProvider(context)
-  } else if (canUseJsonRpcProvider(context)) {
-    provider = initJsonRpcProvider(context)
-  }
-  return assertEx(await provider, () => 'No provider available')
-}
-
-export const canUseEvmProvider = (context: BaseConfigContext) => {
-  return canUseInfuraProvider(context) || canUseJsonRpcProvider(context)
-}

package/src/node/evm/initInfuraProvider.ts

@@ -1,29 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { BaseConfigContext } 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 = (context: BaseConfigContext): Promise<Provider> => {
-  if (instance) return instance
-  const providerConfig = getInfuraProviderConfig(context)
-  instance = Promise.resolve(new InfuraProvider(providerConfig[0], providerConfig[1]))
-  return instance
-}
-
-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 = (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(context), projectId, projectSecret] as const
-}