@xyo-network/chain-services 1.16.26 → 1.17.1

package/src/implementation/head/head.ts

@@ -0,0 +1,49 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import { assertEx, isDefined } from '@xylabs/sdk-js'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type { Initializable, SignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
+import { type ChainService, findMostRecentBlock } from '@xyo-network/xl1-protocol-sdk'
+
+import { createBootstrapHead } from './createBootstrapHead.ts'
+import { createForkedHead } from './createForkedHead/index.ts'
+import { getForkFromBlock } from './getForkFromBlock.ts'
+import { submitNewChain } from './submitNewChain.ts'
+
+let headSingleton: Promisable<SignedBlockBoundWitnessWithHashMeta> | undefined
+
+export const initHead: Initializable<{
+  account: WalletInstance
+  chainArchivist: ArchivistInstance
+  chainService: ChainService
+  chainSubmissionsArchivistWrite: ArchivistInstance
+}, SignedBlockBoundWitnessWithHashMeta>
+  = async (params): Promise<SignedBlockBoundWitnessWithHashMeta> => {
+    const {
+      account, chainArchivist, chainSubmissionsArchivistWrite, chainService,
+    } = params
+    if (headSingleton) return headSingleton
+    let head = await findMostRecentBlock(chainArchivist)
+
+    // If there is a head
+    if (head) {
+      // If there is a head but check if it matches our chainId or we should fork from it
+      const forkFromBlock = await getForkFromBlock(head, chainService, chainArchivist)
+      // If we should fork form a block in the current chain
+      if (isDefined(forkFromBlock)) {
+        // Create a new chain from the fork from block
+        const chain = await createForkedHead(forkFromBlock, account, chainService)
+        await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite)
+        const newBlock = assertEx(chain.at(-1), () => new Error('Failed to get new head after forking'))
+        head = newBlock[0]
+      }
+    } else {
+      // If there is no head, create one
+      const chain = await createBootstrapHead(account, chainService)
+      await submitNewChain(chain, chainArchivist, chainSubmissionsArchivistWrite)
+      const newBlock = assertEx(chain.at(-1), () => new Error('Failed to get new head after genesis'))
+      head = newBlock[0]
+    }
+    headSingleton = head
+    return headSingleton
+  }

package/src/implementation/head/index.ts

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

package/src/implementation/head/submitNewChain.ts

@@ -0,0 +1,27 @@
+import { delay } from '@xylabs/sdk-js'
+import type { ArchivistInstance, WriteArchivist } from '@xyo-network/archivist-model'
+import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import { flattenHydratedBlock } from '@xyo-network/xl1-protocol-sdk'
+
+/**
+ * Submit a new chain to the archivist.
+ * @param chain The new chain to submit
+ * @param chainArchivist The chain archivist instance
+ * @param chainSubmissionsArchivistWrite The chain submissions archivist instance
+ */
+export const submitNewChain = async (
+  chain: SignedHydratedBlockWithHashMeta[],
+  chainArchivist: ArchivistInstance,
+  chainSubmissionsArchivistWrite: WriteArchivist,
+): Promise<void> => {
+  for (const block of chain) {
+    const [bw] = block
+    await chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(block))
+    // Wait for block to show up in finalized archivist
+    while (true) {
+      const result = await chainArchivist.get([bw._hash])
+      if (result.length > 0) break
+      await delay(1000) // Wait 1 second before retrying
+    }
+  }
+}

package/src/implementation/index.ts

@@ -0,0 +1,12 @@
+export * from './accountBalance.ts'
+export * from './blockViewer.ts'
+export * from './chain/index.ts'
+export * from './evm/index.ts'
+export * from './head/index.ts'
+export * from './mempoolRunner.ts'
+export * from './mempoolViewer.ts'
+export * from './pendingTransactions.ts'
+export * from './producer.ts'
+export * from './reward.ts'
+export * from './time.ts'
+export * from './validator.ts'

package/src/implementation/mempoolRunner.ts

@@ -0,0 +1,29 @@
+import { isDefined, type Promisable } from '@xylabs/sdk-js'
+import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
+import type { Config, MempoolRunner } from '@xyo-network/xl1-protocol-sdk'
+import {
+  HttpRpcTransport,
+  JsonRpcMempoolRunner,
+  MempoolRunnerRpcSchemas,
+} from '@xyo-network/xl1-rpc'
+
+let mempoolRunnerSingleton: Promisable<MempoolRunner> | undefined
+
+export type InitMempoolRunnerParams = InitializableParams<{
+  config: Config
+}>
+
+export const initMempoolRunner: Initializable<InitMempoolRunnerParams, MempoolRunner>
+  = (params): Promisable<MempoolRunner> => {
+    const { config, logger } = params
+    if (mempoolRunnerSingleton) return mempoolRunnerSingleton
+    const endpoint = config.services?.apiEndpoint
+    if (isDefined(endpoint)) {
+      const transport = new HttpRpcTransport(endpoint, { ...MempoolRunnerRpcSchemas })
+      const runner = new JsonRpcMempoolRunner(transport)
+      logger?.log('Using mempoolRunner RPC service at', endpoint)
+      return runner
+    } else {
+      throw new Error('No MempoolRunner endpoint configured')
+    }
+  }

package/src/implementation/mempoolViewer.ts

@@ -0,0 +1,29 @@
+import { isDefined, type Promisable } from '@xylabs/sdk-js'
+import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
+import type { Config, MempoolViewer } from '@xyo-network/xl1-protocol-sdk'
+import {
+  HttpRpcTransport,
+  JsonRpcMempoolViewer,
+  MempoolViewerRpcSchemas,
+} from '@xyo-network/xl1-rpc'
+
+let mempoolViewerSingleton: Promisable<MempoolViewer> | undefined
+
+export type InitMempoolViewerParams = InitializableParams<{
+  config: Config
+}>
+
+export const initMempoolViewer: Initializable<InitMempoolViewerParams, MempoolViewer>
+  = (params): Promisable<MempoolViewer> => {
+    const { config, logger } = params
+    if (mempoolViewerSingleton) return mempoolViewerSingleton
+    const endpoint = config.services?.apiEndpoint
+    if (isDefined(endpoint)) {
+      const transport = new HttpRpcTransport(endpoint, { ...MempoolViewerRpcSchemas })
+      const viewer = new JsonRpcMempoolViewer(transport)
+      logger?.log('Using MempoolViewer RPC service at', endpoint)
+      return viewer
+    } else {
+      throw new Error('No MempoolViewer endpoint configured')
+    }
+  }

package/src/implementation/pendingTransactions.ts

@@ -0,0 +1,36 @@
+import { isDefined, type Promisable } from '@xylabs/sdk-js'
+import type { Initializable, InitializableParams } from '@xyo-network/xl1-protocol'
+import type { Config, MempoolViewer } from '@xyo-network/xl1-protocol-sdk'
+import { timeBudget } from '@xyo-network/xl1-protocol-sdk'
+import {
+  HttpRpcTransport, JsonRpcMempoolViewer, MempoolViewerRpcSchemas,
+} from '@xyo-network/xl1-rpc'
+
+import { BasePendingTransactionsService, type BasePendingTransactionsServiceParams } from '../PendingTransactions/index.ts'
+
+let serviceSingleton: Promisable<MempoolViewer> | undefined
+
+export type InitPendingTransactionsServiceParams = InitializableParams<{
+  config: Config
+  params?: BasePendingTransactionsServiceParams
+}>
+
+export const initPendingTransactions: Initializable<InitPendingTransactionsServiceParams, MempoolViewer> = async (
+  {
+    config, params, logger,
+  }: InitPendingTransactionsServiceParams,
+): Promise<MempoolViewer> => {
+  if (serviceSingleton) return serviceSingleton
+  return await timeBudget('initPendingTransactions', logger, async () => {
+    const endpoint = config.services?.apiEndpoint
+    if (isDefined(endpoint)) {
+      const transport = new HttpRpcTransport(endpoint, { ...MempoolViewerRpcSchemas })
+      const viewer = new JsonRpcMempoolViewer(transport)
+      logger?.log('Using MempoolViewer RPC service at', endpoint)
+      return viewer
+    } else {
+      serviceSingleton = await BasePendingTransactionsService.create(params)
+    }
+    return serviceSingleton
+  }, 2000, true)
+}

package/src/implementation/producer.ts

@@ -0,0 +1,16 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { type BlockProducerService, timeBudget } from '@xyo-network/xl1-protocol-sdk'
+
+import { SimpleBlockRunner, type SimpleBlockRunnerParams } from '../simple/index.ts'
+
+let serviceSingleton: Promisable<BlockProducerService> | undefined
+
+export const initBlockProducer: Initializable<SimpleBlockRunnerParams, BlockProducerService>
+  = async (params: SimpleBlockRunnerParams): Promise<BlockProducerService> => {
+    if (serviceSingleton) return serviceSingleton
+    return await timeBudget('initBlockProducer', params.logger, async () => {
+      serviceSingleton = await SimpleBlockRunner.create(params)
+      return serviceSingleton
+    }, 2000, true)
+  }

package/src/implementation/reward.ts

@@ -0,0 +1,53 @@
+import type { Logger } from '@xylabs/sdk-js'
+import { assertEx } from '@xylabs/sdk-js'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import type {
+  BlockRewardViewer, ChainContractViewer, Config, SimpleBlockRewardViewerParams,
+} from '@xyo-network/xl1-protocol-sdk'
+import { SimpleBlockRewardViewer, timeBudget } from '@xyo-network/xl1-protocol-sdk'
+
+import { EvmBlockRewardViewer, type EvmBlockRewardViewerParams } from '../BlockReward/EvmBlockRewardViewer.ts'
+import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
+
+let rewardServiceSingleton: Promise<BlockRewardViewer> | undefined
+
+export const initBlockRewardViewer: Initializable<
+  Partial<SimpleBlockRewardViewerParams> & {
+    chainContractViewer: ChainContractViewer
+    config: Pick<Config, 'evm'>
+  },
+  BlockRewardViewer
+> = (params): Promise<BlockRewardViewer> => {
+  if (rewardServiceSingleton) return rewardServiceSingleton
+  return timeBudget('initBlockRewardViewer', params.logger, () => {
+    const { config } = params
+    rewardServiceSingleton = canUseEvmBlockRewardViewer({ config })
+      ? initEvmBlockRewardViewer(params)
+      : initXyoBlockRewardViewer(params as SimpleBlockRewardViewerParams)
+    return rewardServiceSingleton
+  }, 2000, true)
+}
+
+export const initXyoBlockRewardViewer = (params: SimpleBlockRewardViewerParams): Promise<BlockRewardViewer> => {
+  if (rewardServiceSingleton) return rewardServiceSingleton
+  return timeBudget('initXyoBlockRewardViewer', params.logger, () => {
+    rewardServiceSingleton = SimpleBlockRewardViewer.create(params)
+    return rewardServiceSingleton
+  }, 2000, true)
+}
+
+const canUseEvmBlockRewardViewer = (params: { config: Pick<Config, 'evm'> }) => canUseEvmProvider({ config: params.config })
+
+export const initEvmBlockRewardViewer = async (params: ({
+  chainContractViewer: ChainContractViewer
+  config: Pick<Config, 'evm'>
+  logger?: Logger
+})): Promise<BlockRewardViewer> => {
+  if (rewardServiceSingleton) return rewardServiceSingleton
+  return await timeBudget('initEvmBlockRewardViewer', params.logger, async () => {
+    const provider = assertEx(await initEvmProvider(params))
+    const evmBlockRewardViewerParams: EvmBlockRewardViewerParams = { ...params, provider }
+    rewardServiceSingleton = EvmBlockRewardViewer.create(evmBlockRewardViewerParams)
+    return rewardServiceSingleton
+  }, 2000, true)
+}

package/src/implementation/time.ts

@@ -0,0 +1,26 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import { timeBudget, type TimeSyncViewer } from '@xyo-network/xl1-protocol-sdk'
+import type { Config } from 'cosmiconfig'
+
+import { type BaseTimeServiceParams, BaseTimeSyncService } from '../Time/index.ts'
+import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
+
+let timeSyncServiceSingleton: Promisable<TimeSyncViewer> | undefined
+
+export const initTimeService: Initializable<BaseTimeServiceParams<Pick<Config, 'evm'>>, TimeSyncViewer> = async ({
+  blockViewer, config, logger, meterProvider, traceProvider,
+}) => {
+  if (timeSyncServiceSingleton) return timeSyncServiceSingleton
+
+  return await timeBudget('initTimeService', logger, async () => {
+  // Configure provider for optional Ethereum time sync
+    const ethProvider = canUseEvmProvider({ config }) ? await initEvmProvider({ config }) : undefined
+
+    // Create service
+    timeSyncServiceSingleton = BaseTimeSyncService.create({
+      blockViewer, ethProvider, logger, meterProvider, traceProvider,
+    })
+    return await timeSyncServiceSingleton
+  }, 2000, true)
+}

package/src/implementation/validator.ts

@@ -0,0 +1,15 @@
+import type { Promisable } from '@xylabs/sdk-js'
+import type { Initializable } from '@xyo-network/xl1-protocol'
+import type { BlockProducerService } from '@xyo-network/xl1-protocol-sdk'
+
+import type { SimpleBlockRunnerParams } from '../simple/index.ts'
+import { initBlockProducer } from './producer.ts'
+
+let serviceSingleton: Promisable<BlockProducerService> | undefined
+
+export const initValidator: Initializable<SimpleBlockRunnerParams, BlockProducerService>
+  = (params: SimpleBlockRunnerParams): Promisable<BlockProducerService> => {
+    if (serviceSingleton) return serviceSingleton
+    serviceSingleton = initBlockProducer(params)
+    return serviceSingleton
+  }

package/src/index.ts

@@ -1,17 +1,17 @@
 export * from './AccountBalance/index.ts'
-export * from './AccountTransfers/index.ts'
 export * from './BaseService.ts'
-export * from './BlockProducer/index.ts'
 export * from './BlockReward/index.ts'
 export * from './blockViewerFromChainIteratorAndArchivist.ts'
 export * from './ChainBlockNumberIteration/index.ts'
 export * from './ChainService/index.ts'
 export * from './ChainValidator/index.ts'
 export * from './Election/index.ts'
+export * from './implementation/index.ts'
 export * from './model/index.ts'
 export * from './NetworkStakeStepReward/index.ts'
 export * from './PendingTransactions/index.ts'
 export * from './Schemas/index.ts'
+export * from './simple/index.ts'
 export * from './StakeIntent/index.ts'
 export * from './StepStake/index.ts'
 export * from './Time/index.ts'

package/src/simple/block/index.ts

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