@xyo-network/chain-services 1.17.0 → 1.17.1

package/src/implementation/head/createForkedHead/getBridgeIntent.ts

@@ -0,0 +1,51 @@
+import { buildNextBlock, createTransferPayload } from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  BridgeIntent, BridgeIntentFields,
+  SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+import { BridgeIntentSchema, XYO_BRIDGE_ADDRESS } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+import {
+  getBridgeDestinationDetails, getBridgeSourceDetails, getForkBlockReward,
+} from './config/index.ts'
+
+/**
+ * Get the bridge intent for a given block.
+ * @param previousBlock The previous block to base the intent on.
+ * @param account The wallet account to use for the intent.
+ * @param chainService The chain service to use for the intent.
+ */
+export const getBridgeIntent = async (
+  previousBlock: SignedHydratedBlockWithHashMeta,
+  account: WalletInstance,
+  chainService: ChainService,
+): Promise<SignedHydratedBlockWithHashMeta> => {
+  // Create transfer to bridge address
+  const transferPayload = createTransferPayload(
+    account.address,
+    { [XYO_BRIDGE_ADDRESS]: getForkBlockReward() },
+  )
+
+  // Use timestamp as nonce
+  const nonce = `${Date.now()}`
+
+  // Create Bridge Intent
+  const bridgeIntentFields: BridgeIntentFields = {
+    ...await getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    nonce,
+  }
+  const bridgeIntent = new PayloadBuilder<BridgeIntent>({ schema: BridgeIntentSchema })
+    .fields(bridgeIntentFields)
+    .build()
+
+  return await buildNextBlock(
+    previousBlock[0],
+    [],
+    [bridgeIntent, transferPayload],
+    [account],
+  )
+}

package/src/implementation/head/createForkedHead/getBridgeSourceObservation.ts

@@ -0,0 +1,46 @@
+import { buildNextBlock } from '@xyo-network/chain-protocol'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  BridgeSourceObservation, BridgeSourceObservationFields,
+  SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+import { BridgeSourceObservationSchema } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+import { getBridgeDestinationDetails, getBridgeSourceDetails } from './config/index.ts'
+
+/**
+ * Get the bridge source observation for a given block.
+ * @param previousBlock The previous block to base the observation on.
+ * @param account The wallet account to use for the observation.
+ * @param chainService The chain service to use for the observation.
+ */
+export const getBridgeSourceObservation = async (
+  previousBlock: SignedHydratedBlockWithHashMeta,
+  account: WalletInstance,
+  chainService: ChainService,
+): Promise<SignedHydratedBlockWithHashMeta> => {
+  // TODO: Find actual transfer TX from previous block/source intent?
+  // This hash should contain both the source intent and the transfer to the bridge address
+  // As the block is itself both a block and a transaction, we can use its hash for now
+  const srcTxHash = previousBlock[0]._hash
+
+  const bridgeSourceObservationFields: BridgeSourceObservationFields = {
+    ...await getBridgeSourceDetails(account, chainService),
+    ...getBridgeDestinationDetails(),
+    // Observation
+    srcConfirmation: srcTxHash,
+  }
+
+  const bridgeSourceObservation = new PayloadBuilder<BridgeSourceObservation>({ schema: BridgeSourceObservationSchema })
+    .fields(bridgeSourceObservationFields)
+    .build()
+
+  return await buildNextBlock(
+    previousBlock[0],
+    [],
+    [bridgeSourceObservation],
+    [account],
+  )
+}

package/src/implementation/head/createForkedHead/getFirstBlockForNewChain.ts

@@ -0,0 +1,41 @@
+import { buildBlock, type BuildNextBlockOptions } from '@xyo-network/chain-protocol'
+import type { WithHashMeta } from '@xyo-network/payload-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+import type {
+  BlockBoundWitness,
+  SignedHydratedBlockWithHashMeta,
+} from '@xyo-network/xl1-protocol'
+import { AttoXL1, XYO_STEP_REWARD_ADDRESS } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+/**
+ * Get the first block for the new forked chain.
+ * @param forkBlock The block to fork from
+ * @param account The wallet account to sign the block
+ * @param chainService The chain service instance
+ * @returns The first block for the new forked chain
+ */
+export const getFirstBlockForNewChain = async (
+  forkBlock: WithHashMeta<BlockBoundWitness>,
+  account: WalletInstance,
+  chainService: ChainService,
+): Promise<SignedHydratedBlockWithHashMeta> => {
+  const {
+    _hash: previousBlockHash, block: previousBlockNumber, step_hashes: previousStepHashes = [], protocol,
+  } = forkBlock
+  const chainId = await chainService.chainId()
+  const options: BuildNextBlockOptions = {
+    blockPayloads: [],
+    chainId,
+    previousBlockHash,
+    previousBlockNumber,
+    previousStepHashes,
+    signers: [account],
+    txs: [],
+    protocol,
+    chainStepRewardAddress: XYO_STEP_REWARD_ADDRESS,
+    stepRewardPoolBalance: AttoXL1(0n),
+  }
+  // Can not use buildNextBlock because we need to control the chain id change here
+  return await buildBlock(options)
+}

package/src/implementation/head/createForkedHead/index.ts

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

package/src/implementation/head/getForkFromBlock.ts

@@ -0,0 +1,43 @@
+import type { Address, Hash } from '@xylabs/sdk-js'
+import {
+  asHash, hexFromBigInt, isDefined,
+} from '@xylabs/sdk-js'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { SignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
+import { isSignedBlockBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
+
+/**
+ * Determine if the chain should fork based on the current head and chain configuration.
+ * @param head The current head block
+ * @param chainService The chain service instance
+ * @param chainArchivist The chain archivist instance
+ * @returns The block to fork from if the chain should fork, undefined otherwise
+ */
+export const getForkFromBlock = async (
+  head: SignedBlockBoundWitnessWithHashMeta,
+  chainService: ChainService,
+  chainArchivist: ArchivistInstance,
+): Promise<SignedBlockBoundWitnessWithHashMeta | undefined> => {
+  // If the head's chain doesn't match our chainId, we may need to fork
+  if (head.chain !== await chainService.chainId()) {
+    // Get the forked at hash from the chain service
+    const forkedAtBigInt = await chainService.forkedAtHash()
+    const forkedAtHex = hexFromBigInt(forkedAtBigInt) // Validate it's a proper hex string
+    const forkedAtHash: Hash | undefined = asHash(forkedAtHex)
+    if (isDefined(forkedAtHash)) {
+      // If we have a forkedAtHash, we need to check if the correct block exists
+      const [forkedAtBlock] = await chainArchivist.get([forkedAtHash])
+      const forkedChainId: Address = await chainService.forkedChainId()
+      const forkedAtBlockNumber: number = Number(await chainService.forkedAtBlockNumber())
+      // If we found the block hash we should fork at, check if it's a valid BlockBoundWitness
+      if (isSignedBlockBoundWitnessWithHashMeta(forkedAtBlock)
+      // And it is on the correct forked from chain
+        && forkedAtBlock.chain === forkedChainId
+        // And it is the correct forked at block number
+        && forkedAtBlock.block === forkedAtBlockNumber) {
+        return forkedAtBlock
+      }
+    }
+  }
+}

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'