@xyo-network/xl1-cli 1.7.4 → 1.7.6

package/src/orchestration/initServices.ts

@@ -1,241 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-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 { Config } from '@xyo-network/chain-protocol'
-import type { BaseBlockProducerServiceParams, 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 type { ChainInitializableParams } from './ChainInitializableParams.ts'
-import { initHealthEndpoints } from './health/index.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'
-}
-
-interface InitServicesContext {
-  config: Config
-  logger: Logger
-}
-
-export const initServices = async (context: InitServicesContext): Promise<ChainServiceCollectionV2> => {
-  const { config, logger } = context
-  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)
-  })
-
-  await startupSpanAsync('initHealthEndpoints', () => initHealthEndpoints({ statusReporter }))
-
-  const [
-    { traceProvider, meterProvider },
-    account,
-  ] = await Promise.all([
-    startupSpanAsync('initTelemetry', () => initTelemetry(telemetryConfig)),
-    startupSpanAsync('initAccount', () => initAccount({ logger })),
-  ])
-
-  const initParams: ChainInitializableParams = {
-    logger, traceProvider, meterProvider, statusReporter,
-  }
-
-  // Archivists
-  const [
-    chainArchivist,
-    [pendingBundledTransactionsArchivist, pendingBundledTransactionsArchivistWrite],
-    rejectedTransactionsArchivist,
-    chainSubmissionsArchivistWrite,
-    stakeIntentStateArchivist,
-    chainService,
-    balanceSummaryMap,
-  ] = await Promise.all([
-    startupSpanAsync(
-      'ChainFinalizedArchivist',
-      () => initChainFinalizedArchivist(initParams),
-    ),
-    startupSpanAsync(
-      'PendingBundledTransactionsArchivist',
-      () => initPendingBundledTransactionsArchivist(initParams),
-    ),
-    startupSpanAsync(
-      'RejectedTransactionsArchivist',
-      () => initRejectedTransactionsArchivist(initParams),
-    ),
-    startupSpanAsync(
-      'ChainSubmissionsArchivist',
-      () => initChainSubmissionsArchivist(initParams),
-    ),
-    startupSpanAsync(
-      'StakeIntentStateArchivist',
-      () => initStakeIntentStateArchivist(initParams),
-    ),
-    startupSpanAsync(
-      'ChainService',
-      () => initChainService({
-        ...initParams, account, name: 'ChainService',
-      }),
-    ),
-    startupSpanAsync(
-      'BalanceSummaryMap',
-      () => initBalanceSummaryMap(initParams),
-    ),
-  ])
-
-  const chainId = chainService.chainId
-  const chainContractViewer = chainService
-  const chainStakeViewer = chainService
-  const chainStaker = chainService
-  const head = await startupSpanAsync('initHead', () => initHead({
-    ...initParams, account, chainArchivist, chainSubmissionsArchivistWrite,
-  }))
-  const [
-    pendingTransactionsService,
-    rewardService,
-    chainIterator,
-    balanceService,
-  ] = await Promise.all([
-    startupSpanAsync('PendingTransactions', () => initPendingTransactions({
-      name: 'PendingTransactionsService',
-      chainArchivist,
-      chainId,
-      pendingBundledTransactionsArchivist,
-      rejectedTransactionsArchivist,
-      ...initParams,
-    })),
-    startupSpanAsync(
-      'RewardService',
-      () => initBlockRewardService({
-        name: 'RewardService',
-        account,
-        chainService,
-        ...initParams,
-      }),
-    ),
-    startupSpanAsync(
-      'ChainIterator',
-      () => initChainIterator({
-        name: 'ChainIterator',
-        chainArchivist,
-        head,
-        ...initParams,
-      }),
-    ),
-    startupSpanAsync(
-      'BalanceService',
-      () => initBalanceService({
-        name: 'BalanceService',
-        chainArchivist,
-        summaryRepository: balanceSummaryRepositoryFromMap(balanceSummaryMap),
-        ...initParams,
-      }),
-    ),
-  ])
-
-  const stakeIntentService = await startupSpanAsync(
-    'StakeIntentService',
-    () => initStakeIntentService({
-      name: 'StakeIntentService',
-      chainArchivist,
-      chainIterator,
-      chainStakeViewer,
-      stakeIntentStateArchivist,
-      ...initParams,
-    }),
-  )
-
-  const electionService = await startupSpanAsync(
-    'ElectionService',
-    () => initElectionService({
-      name: 'ElectionService',
-      chainIterator,
-      chainStakeViewer,
-      stakeIntentService,
-      ...initParams,
-    }),
-  )
-
-  const validatorParams: XyoValidatorParams = {
-    name: 'Validator',
-    account,
-    chainId,
-    pendingBundledTransactionsArchivist,
-    chainArchivist,
-    electionService,
-    rewardService,
-    stakeIntentService,
-    validateHydratedBlockState,
-    ...initParams,
-  }
-  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,
-    ...initParams,
-  }
-  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,
-  }
-
-  logger?.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

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

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

@@ -1,22 +0,0 @@
-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 type { ChainInitializableParams } from '../../ChainInitializableParams.ts'
-import { initLocalBalanceSummaryMap } from './local.ts'
-
-const mutex = new Mutex()
-let singleton: MapType<Hash, WithStorageMeta<BalancesStepSummary>> | undefined
-
-export async function initBalanceSummaryMap(params: ChainInitializableParams): Promise<MapType<Hash, WithStorageMeta<BalancesStepSummary>>> {
-  return await mutex.runExclusive(async () => {
-    if (isDefined(singleton)) return singleton
-    const local = await startupSpanAsync('BalanceSummaryMap:initLocal', () => initLocalBalanceSummaryMap(params))
-    singleton = local
-    return singleton
-  })
-}

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

@@ -1,20 +0,0 @@
-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 type { ChainInitializableParams } from '../../ChainInitializableParams.ts'
-import { getLocalPersistentMap } from '../localPersistentMap.ts'
-
-const mutex = new Mutex()
-let singleton: MapType<Hash, WithStorageMeta<BalancesStepSummary>> | undefined
-
-export const initLocalBalanceSummaryMap = async (_params: ChainInitializableParams): 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

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

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

@@ -1,7 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

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

package/src/orchestration/map/index.ts

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

package/src/orchestration/map/localPersistentMap.ts

@@ -1,39 +0,0 @@
-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

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

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

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

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

@@ -1,27 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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, InitializableParams } from '@xyo-network/xl1-protocol'
-
-let accountServiceSingleton: Promisable<WalletInstance> | undefined
-
-export const initAccount: Initializable<InitializableParams, WalletInstance> = async ({ logger }): Promise<WalletInstance> => {
-  if (accountServiceSingleton) return accountServiceSingleton
-  let walletPhrase = process.env.XYO_WALLET_MNEMONIC
-  if (isUndefined(walletPhrase)) {
-    logger?.log('No wallet mnemonic specified!')
-    const randomMnemonic = HDWallet.generateMnemonic()
-    logger?.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

@@ -1,13 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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
-}

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

@@ -1,27 +0,0 @@
-import type { Promisable } from '@xylabs/promise'
-import type { BaseAccountableServiceParams } from '@xyo-network/chain-services'
-import { MemoryChainService } from '@xyo-network/chain-services'
-import type { ChainService, Initializable } from '@xyo-network/xl1-protocol'
-
-import { canUseEvmContractChainService, initEvmContractChainService } from './evm.ts'
-
-let chainStakeServiceSingleton: Promisable<ChainService> | undefined
-
-export const initChainService: Initializable<BaseAccountableServiceParams, ChainService> = ({ account }) => init({ name: 'ChainService', account })
-
-const init: Initializable<BaseAccountableServiceParams, ChainService> = ({
-  account, traceProvider, meterProvider, logger,
-}): Promisable<ChainService> => {
-  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
-  chainStakeServiceSingleton = canUseEvmContractChainService()
-    ? initEvmContractChainService({
-        name: 'ChainStakeService',
-        account,
-        traceProvider,
-        meterProvider,
-        logger,
-      })
-    : MemoryChainService.create({})
-  // Create service
-  return chainStakeServiceSingleton
-}

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

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

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

@@ -1,18 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { hexFrom, isHex } from '@xylabs/hex'
-
-export const canUseChainId = (): boolean => {
-  return process.env.XYO_JSON_RPC_NETWORK !== undefined
-}
-
-export const getChainId = () => {
-  const chainId = assertEx(process.env.XYO_JSON_RPC_NETWORK, () => 'Missing XYO_JSON_RPC_NETWORK ENV VAR')
-  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/orchestration/services/implementation/evm/initEvmProvider.ts

@@ -1,21 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { JsonRpcProvider } from 'ethers/providers'
-
-import { canUseJsonRpcProvider, initJsonRpcProvider } from './initGanacheProvider.ts'
-import { canUseInfuraProvider, initInfuraProvider } from './initInfuraProvider.ts'
-
-let provider: Promise<JsonRpcProvider> | undefined
-
-export const initEvmProvider = async () => {
-  if (provider) return provider
-  if (canUseInfuraProvider()) {
-    provider = initInfuraProvider()
-  } else if (canUseJsonRpcProvider()) {
-    provider = initJsonRpcProvider()
-  }
-  return assertEx(await provider, () => 'Error: No provider available')
-}
-
-export const canUseEvmProvider = () => {
-  return canUseInfuraProvider() || canUseJsonRpcProvider()
-}

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

@@ -1,19 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { JsonRpcProvider } from 'ethers/providers'
-
-import { canUseChainId, getChainId } from './initChainId.ts'
-
-export const initJsonRpcProvider = () => {
-  const config = getJsonRpcProviderConfig()
-  return Promise.resolve(new JsonRpcProvider(...config))
-}
-
-export const canUseJsonRpcProvider = () => {
-  return canUseChainId()
-    && process.env.XYO_JSON_RPC_URL !== undefined
-}
-
-export const getJsonRpcProviderConfig = () => {
-  const jsonRpcUrl = assertEx(process.env.XYO_JSON_RPC_URL, () => 'Missing XYO_JSON_RPC_URL ENV VAR')
-  return [jsonRpcUrl, getChainId()] as const
-}

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

@@ -1,25 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { InfuraProvider } from 'ethers/providers'
-
-import { canUseChainId, getChainId } from './initChainId.ts'
-
-let instance: Promise<InfuraProvider> | undefined
-
-export const initInfuraProvider = () => {
-  if (instance) return instance
-  const config = getInfuraProviderConfig()
-  instance = Promise.resolve(new InfuraProvider(...config))
-  return instance
-}
-
-export const canUseInfuraProvider = (): boolean => {
-  return canUseChainId()
-    && process.env.INFURA_PROJECT_ID != undefined
-    && process.env.INFURA_PROJECT_SECRET != undefined
-}
-
-export const getInfuraProviderConfig = () => {
-  const projectId = assertEx(process.env.INFURA_PROJECT_ID, () => 'Missing INFURA_PROJECT_ID ENV VAR')
-  const projectSecret = assertEx(process.env.INFURA_PROJECT_SECRET, () => 'Missing INFURA_PROJECT_SECRET ENV VAR')
-  return [getChainId(), projectId, projectSecret] as const
-}