@xyo-network/chain-services 1.17.0 → 1.17.1

package/src/{BlockProducer/BaseBlockProducerService.ts → simple/block/runner/SimpleBlockRunner.ts}

@@ -1,7 +1,10 @@
-/* eslint-disable max-statements */
 import {
-  Address, AddressZod, asHash, assertEx, creatable, exists, Hex, hexToBigInt, isDefined, toHex,
+  AbstractCreatable,
+  Address,
+  AddressZod, asHash, assertEx, creatable, CreatableParams, exists, Hex, hexToBigInt, isDefined, Promisable,
 } from '@xylabs/sdk-js'
+import { AccountInstance } from '@xyo-network/account-model'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
 import {
   BlockRewardDiviner, FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema,
@@ -11,16 +14,20 @@ import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { WithHashMeta } from '@xyo-network/payload-model'
 import {
   AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumberPayload, BlockNumberSchema,
-  ChainStakeIntent, defaultRewardRatio, HydratedBlockWithHashMeta, SignedHydratedTransaction, TimePayload, TimeSchema,
+  ChainId,
+  ChainStakeIntent, defaultRewardRatio, SignedBlockBoundWitnessWithHashMeta,
+  SignedHydratedBlockWithHashMeta, SignedHydratedTransaction, TimePayload, TimeSchema,
   Transfer, XYO_STEP_REWARD_ADDRESS,
 } from '@xyo-network/xl1-protocol'
 import {
-  AccountBalanceViewer, BlockProducerService, Config, MempoolViewer, StakeIntentService, TimeSyncViewer,
+  AccountBalanceViewer, BlockRewardViewer, BlockRunner, Config,
+  HydratedBlockStateValidationFunction,
+  MempoolRunner,
+  MempoolViewer,
+  TimeSyncViewer,
 } from '@xyo-network/xl1-protocol-sdk'
 import z from 'zod'
 
-import { BaseService } from '../BaseService.ts'
-import { XyoValidatorParams } from '../ChainValidator/index.ts'
 import { generateTransactionFeeTransfers } from './generateTransactionFeeTransfers.ts'
 
 /**
@@ -39,25 +46,38 @@ export const XYO_PRODUCER_REDECLARATION_DURATION = 10_000
  */
 export const XYO_PRODUCER_REDECLARATION_WINDOW = 500
 
-export const BaseBlockProducerServiceParamsZod = z.object({
-  balanceService: z.object().loose(),
-  pendingTransactionsService: z.object().loose(),
-  rejectedTransactionsArchivist: z.object().loose(),
+export const SimpleBlockRunnerParamsZod = z.object({
+  balanceViewer: z.object().loose(),
+  blockRewardViewer: z.object().loose(),
+  chainId: z.string(),
+  config: z.object().loose(),
+  mempoolViewer: z.object().loose(),
+  mempoolRunner: z.object().loose(),
+  rejectedTransactionsArchivist: z.object().loose().optional(),
   rewardAddress: AddressZod,
   time: z.object().loose(),
+  validateHydratedBlockState: z.function().optional(),
 })
 
-export interface BaseBlockProducerServiceParams extends XyoValidatorParams<Pick<Config, 'producer'>> {
-  balanceService: AccountBalanceViewer
-  pendingTransactionsService: MempoolViewer
-  rejectedTransactionsArchivist: ArchivistInstance
+export type SimpleBlockRunnerParams = CreatableParams & {
+  account: AccountInstance
+  balanceViewer: AccountBalanceViewer
+  blockRewardViewer: BlockRewardViewer
+  chainId: ChainId
+  config: Config
+  mempoolRunner: MempoolRunner
+  mempoolViewer: MempoolViewer
+  rejectedTransactionsArchivist?: ArchivistInstance
   rewardAddress: Address
   time: TimeSyncViewer
+  validateHydratedBlockState?: HydratedBlockStateValidationFunction
 }
 
 @creatable()
-export class BaseBlockProducerService extends BaseService<BaseBlockProducerServiceParams> implements BlockProducerService {
+export class SimpleBlockRunner extends AbstractCreatable<SimpleBlockRunnerParams> implements BlockRunner {
   protected _blockRewardDiviner: BlockRewardDiviner | undefined
+  protected _lastRedeclarationBlock: number | undefined
+  protected _rejectedTransactionsArchivist: ArchivistInstance | undefined
 
   /**
    * The default block size for a block
@@ -90,70 +110,85 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return assertEx(this.params.account, () => 'account is required')
   }
 
-  protected get balanceService() {
-    return assertEx(this.params.balanceService, () => 'balanceService is required')
+  protected get balanceViewer() {
+    return assertEx(this.params.balanceViewer, () => 'balanceViewer is required')
   }
 
-  protected get blockViewer() {
-    return assertEx(this.params.blockViewer, () => 'blockViewer is required')
+  protected get blockRewardViewer() {
+    return assertEx(this.params.blockRewardViewer, () => 'blockRewardViewer is required')
   }
 
   protected get chainId() {
     return assertEx(this.params.chainId, () => 'chainId is required')
   }
 
-  protected get electionService() {
-    return assertEx(this.params.electionService, () => 'electionService is required')
+  // protected get electionService() {
+  //   return assertEx(this.params.electionService, () => 'electionService is required')
+  // }
+
+  protected get mempoolRunner() {
+    return assertEx(this.params.mempoolRunner, () => 'mempoolRunner is required')
   }
 
-  protected get pendingTransactionsService() {
-    return assertEx(this.params.pendingTransactionsService, () => 'Missing pendingTransactionsService')
+  protected get mempoolViewer() {
+    return assertEx(this.params.mempoolViewer, () => 'mempoolViewer is required')
   }
 
+  // protected get pendingTransactionsService() {
+  //   return assertEx(this.params.pendingTransactionsService, () => 'Missing pendingTransactionsService')
+  // }
+
   protected get rejectedTransactionsArchivist() {
-    return assertEx(this.params.rejectedTransactionsArchivist, () => 'No rejected bundled transactions archivist')
+    return this._rejectedTransactionsArchivist!
   }
 
   protected get rewardAddress(): Address {
     return assertEx(this.params.rewardAddress, () => 'No reward address provided')
   }
 
-  protected get rewardService() {
-    return assertEx(this.params.rewardService, () => 'rewardService is required')
-  }
-
-  protected get stakeIntentService(): StakeIntentService {
-    return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
-  }
+  // protected get stakeIntentService(): StakeIntentService {
+  //   return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
+  // }
 
   protected get time(): TimeSyncViewer {
     return assertEx(this.params.time, () => 'No TimeSyncViewer provided')
   }
 
-  protected get validateHydratedBlockState() {
-    return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
-  }
+  // protected get validateHydratedBlockState() {
+  //   return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
+  // }
 
-  static override async paramsHandler(params?: Partial<BaseBlockProducerServiceParams> | undefined): Promise<BaseBlockProducerServiceParams> {
+  static override async paramsHandler(params?: Partial<SimpleBlockRunnerParams> | undefined): Promise<SimpleBlockRunnerParams> {
     // TODO: Use a real zod and move the zod check to the AbstractCreatable class
-    BaseBlockProducerServiceParamsZod.parse(params)
-    return { ...(await super.paramsHandler(params)), ...params } as BaseBlockProducerServiceParams
+    SimpleBlockRunnerParamsZod.parse(params)
+    const rejectedTransactionsArchivist = params?.rejectedTransactionsArchivist ?? await MemoryArchivist.create()
+    return {
+      ...(await super.paramsHandler(params)), ...params, rejectedTransactionsArchivist,
+    } as SimpleBlockRunnerParams
   }
 
-  async next(head: WithHashMeta<BlockBoundWitness>): Promise<HydratedBlockWithHashMeta | undefined> {
+  async next(head: WithHashMeta<BlockBoundWitness>): Promise<SignedHydratedBlockWithHashMeta | undefined> {
     // If the block is for another chain, ignore
     if (head.chain !== this.chainId) return
-    const leadersStart = Date.now()
-    const leaders = await this.electionService.getCreatorCommitteeForNextBlock(head)
-    const leadersDuration = Date.now() - leadersStart
-    if (leadersDuration > 100) {
-      this.logger?.warn(`[Slow] Fetched leaders in ${leadersDuration}ms: ${leaders.map(l => l.slice(0, 6)).join(', ')}`)
-    }
+    // const leadersStart = Date.now()
+    // const leaders = await this.electionService.getCreatorCommitteeForNextBlock(head)
+    // const leadersDuration = Date.now() - leadersStart
+    // if (leadersDuration > 100) {
+    //   this.logger?.warn(`[Slow] Fetched leaders in ${leadersDuration}ms: ${leaders.map(l => l.slice(0, 6)).join(', ')}`)
+    // }
     // TODO: Should we propose block if creator committee is empty?
     // TODO: Handle the case where we're not the 1st leader but they're not responding
     // at a higher level than here as that's a network issue
-    if (!leaders.includes(this.address)) return
-    return this.proposeNextValidBlock(head)
+    // if (!leaders.includes(this.address)) return
+    return await this.proposeNextValidBlock(head)
+  }
+
+  async produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force: true): Promise<SignedHydratedBlockWithHashMeta>
+  async produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: false): Promise<SignedHydratedBlockWithHashMeta | undefined>
+  async produceNextBlock(head: SignedBlockBoundWitnessWithHashMeta, force?: boolean): Promise<SignedHydratedBlockWithHashMeta | undefined> {
+    assertEx(head.chain === this.chainId, () => 'Block chain ID does not match')
+    const result = await this.proposeNextValidBlock(head)
+    return force ? assertEx(result, () => 'Failed to produce next block') : result
   }
 
   protected async getBlockRewardTransfers(block: number): Promise<Transfer[]> {
@@ -161,7 +196,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       // TODO: Adjust to allow for genesis block reward vs. normal block reward
       this._blockRewardDiviner = await FixedPercentageBlockRewardDiviner.create({
         account: 'random',
-        blockRewardService: this.rewardService,
+        blockRewardViewer: this.blockRewardViewer,
         config: {
           rewardAddress: this.rewardAddress,
           rewardPercentageRatio: defaultRewardRatio,
@@ -169,8 +204,8 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
         },
       })
     }
-    const blockHex = assertEx(toHex(block), () => 'Failed to convert block to hex')
-    const blockId = new PayloadBuilder<BlockNumberPayload>({ schema: BlockNumberSchema }).fields({ block: blockHex }).build()
+
+    const blockId = new PayloadBuilder<BlockNumberPayload>({ schema: BlockNumberSchema }).fields({ block }).build()
     const rewards = await this._blockRewardDiviner.divine([blockId])
     return rewards as Transfer[]
   }
@@ -180,30 +215,31 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
    * @param head The current head block
    * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
    */
-  protected async getProducerRedeclaration(head: WithHashMeta<BlockBoundWitness>): Promise<ChainStakeIntent | undefined> {
+  protected getProducerRedeclaration(head: WithHashMeta<BlockBoundWitness>): Promisable<ChainStakeIntent | undefined> {
+    // TODO: Do not redeclare on every block
     // Decide if we should redeclare intent
     if (this.params.config.producer.disableIntentRedeclaration) return
     // Decide if we need to redeclare intent
-    const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.address, 'producer')
+    // const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.address, 'producer')
     // TODO: This doesn't handle the case where the producer had declared a range for the future
     // but we're in a range that's not the future
     // Sort in ascending order based on ending range to get range with highest ending block
-    const lastRange = ranges.toSorted((a, b) => a[1] > b[1] ? 1 : -1).at(-1)
-    if (!lastRange) return
-    const [, currentDeclarationEnd] = lastRange
+    // const lastRange = ranges.toSorted((a, b) => a[1] > b[1] ? 1 : -1).at(-1)
+    // if (!lastRange) return
+    // const [, currentDeclarationEnd] = lastRange
     const currentBlock = head.block
-    const timeToProducerExpiration = currentDeclarationEnd - currentBlock
-    if (timeToProducerExpiration > BaseBlockProducerService.RedeclarationWindow) return
-    return createDeclarationIntent(this.address, 'producer', currentBlock, currentBlock + BaseBlockProducerService.RedeclarationDuration)
+    // const timeToProducerExpiration = currentDeclarationEnd - currentBlock
+    // if (timeToProducerExpiration > BaseBlockProducerService.RedeclarationWindow) return
+    return createDeclarationIntent(this.address, 'producer', currentBlock, currentBlock + SimpleBlockRunner.RedeclarationDuration)
   }
 
-  protected async proposeNextValidBlock(head: WithHashMeta<BlockBoundWitness>, validateBalances = false): Promise<HydratedBlockWithHashMeta | undefined> {
+  protected async proposeNextValidBlock(head: WithHashMeta<BlockBoundWitness>, validateBalances = false, force = false) {
     return await this.spanAsync('proposeNextValidBlock', async () => {
       // Calculate the next block components
       const { block: previousBlock } = assertEx(asBlockBoundWitness(head), () => 'Invalid head block')
       const nextBlock = previousBlock + 1
       const nextBlockTransactionsStart = Date.now()
-      const nextBlockTransactions = await this.pendingTransactionsService.pendingTransactions({ limit: BaseBlockProducerService.DefaultBlockSize })
+      const nextBlockTransactions = await this.mempoolViewer.pendingTransactions({ limit: SimpleBlockRunner.DefaultBlockSize })
       const nextBlockTransactionsDuration = Date.now() - nextBlockTransactionsStart
       if (nextBlockTransactionsDuration > 200) {
         this.logger?.warn(`[Slow] Fetched ${nextBlockTransactions.length} pending transactions in ${nextBlockTransactionsDuration}ms}`)
@@ -216,7 +252,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       if (producerRedeclarationPayload) blockPayloads.push(producerRedeclarationPayload)
 
       // If there are no transactions, no payloads and no heartbeat required, we don't need to create a block
-      if (blockPayloads.length === 0 && nextBlockTransactions.length === 0 && !this.heartbeatRequired(head)) return
+      if (blockPayloads.length === 0 && nextBlockTransactions.length === 0 && !this.heartbeatRequired(head) && !force) return
 
       // Calculate the optional block reward transfer and add if necessary
       const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock)
@@ -237,25 +273,26 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       // Build the block
       this.logger?.info(`Building block ${head.block + 1}`)
       const startBuild = Date.now()
-      const stepRewardPoolBalance = (await this.balanceService.accountsBalances([XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS]
+      const stepRewardPoolBalance = (await this.balanceViewer.accountBalances([XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS]
       const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance)
 
       this.logger?.info(
         `Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`,
       )
 
-      this.logger?.info(`Validating block ${block[0].block} with ${block[1].length} payloads`)
-      const startValidate = Date.now()
-      const errors = await this.validateHydratedBlockState(block, this.chainId, { accountBalance: this.balanceService })
-      this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`)
-
-      if (errors.length > 0) {
-        this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`)
-        const rejectedTransactions = block[1]
-        await this.rejectedTransactionsArchivist.insert(rejectedTransactions)
-      } else {
-        return block
-      }
+      // this.logger?.info(`Validating block ${block[0].block} with ${block[1].length} payloads`)
+      // const startValidate = Date.now()
+      // const errors = await this.validateHydratedBlockState(block, this.chainId, { accountBalance: this.balanceViewer })
+      // this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`)
+
+      // if (errors.length > 0) {
+      //   this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`)
+      //   const rejectedTransactions = block[1]
+      //   await this.rejectedTransactionsArchivist.insert(rejectedTransactions)
+      // } else {
+      await this.mempoolRunner.submitBlocks([block])
+      return block
+      // }
     })
   }
 
@@ -272,7 +309,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       if (!transfer) return
       const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? '00' as Hex), 0n)
       if (validateBalances) {
-        const balance = (await this.balanceService.accountsBalances([transfer.from]))[transfer.from] ?? AttoXL1(0n)
+        const balance = (await this.balanceViewer.accountBalances([transfer.from]))[transfer.from] ?? AttoXL1(0n)
         if (balance >= totalTransferCost) {
           fundedTransfers.push(transfer)
           return tx

package/src/simple/block/runner/index.ts

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