@xyo-network/chain-services 1.20.14 → 1.20.16

package/src/ChainValidator/model/Validator.ts

@@ -1,7 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { BlockBoundWitness, SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-sdk'
-
-export interface Validator {
-  validatePendingBlock(block: BlockBoundWitness): Promisable<Error[]>
-  validatePendingTransaction(tx: SignedHydratedTransactionWithStorageMeta): Promise<boolean>
-}

package/src/ChainValidator/model/index.ts

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

package/src/Election/BaseElectionService.ts

@@ -1,55 +0,0 @@
-import {
-  Address, assertEx, Hash,
-} from '@xylabs/sdk-js'
-import { hexToLast4BytesInt, shuffleWithSeed } from '@xyo-network/chain-utils'
-import { WithHashMeta } from '@xyo-network/sdk-js'
-import {
-  AbstractCreatableProvider,
-  type BlockViewer,
-  type ChainStakeViewer, creatableProvider,
-  type ElectionService, type StakeIntentService,
-} from '@xyo-network/xl1-sdk'
-import { BlockBoundWitness } from '@xyo-network/xl1-sdk'
-
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseElectionServicesParams extends BaseServiceParams {
-  blockViewer?: BlockViewer
-  chainStakeViewer?: ChainStakeViewer
-  stakeIntentService?: StakeIntentService
-}
-
-@creatableProvider()
-export class BaseElectionService extends AbstractCreatableProvider<BaseElectionServicesParams> implements ElectionService {
-  static readonly defaultMoniker = 'Election'
-  static readonly dependencies = []
-  static readonly monikers = ['Election']
-  moniker = BaseElectionService.defaultMoniker
-  get blockViewer() {
-    return assertEx(this.params.blockViewer, () => 'No block viewer')
-  }
-
-  get chainStakeViewer() {
-    return assertEx(this.params.chainStakeViewer, () => 'No chain stake viewer')
-  }
-
-  get stakeIntentService() {
-    return assertEx(this.params.stakeIntentService, () => 'No staked intent service')
-  }
-
-  async getCreatorCommitteeForNextBlock(current: WithHashMeta<BlockBoundWitness>): Promise<Address[]> {
-    return await this.spanAsync('getCreatorCommitteeForNextBlock', async () => {
-      const nextBlock = current.block + 1
-      const candidates = await this.stakeIntentService.getDeclaredCandidatesForBlock(nextBlock, 'producer')
-      const previousBlockHash = current._hash
-      return this.generateCreatorCommittee(candidates, previousBlockHash)
-    }, this.context)
-  }
-
-  protected generateCreatorCommittee(candidates: Address[], previousBlockHash: Hash, maxSize = 3): Address[] {
-    const creators = new Set<Address>(candidates)
-    const seed = hexToLast4BytesInt(previousBlockHash)
-    const creatorArray = shuffleWithSeed(creators, seed)
-    return creatorArray.slice(0, maxSize)
-  }
-}

package/src/Election/index.ts

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

package/src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -1,99 +0,0 @@
-import { Address, Promisable } from '@xylabs/sdk-js'
-import { ReadArchivist } from '@xyo-network/sdk-js'
-import {
-  AbstractCreatableProvider,
-  AttoXL1,
-  creatableProvider,
-  NetworkStakeStepRewardService, NetworkStakeStepRewardViewerMoniker,
-  StepIdentity,
-  StepIdentityString,
-} from '@xyo-network/xl1-sdk'
-import { Provider } from 'ethers'
-
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseNetworkStakeStepRewardServiceParams extends BaseServiceParams {
-  chainArchivist: ReadArchivist
-  ethProvider?: Provider
-}
-
-@creatableProvider()
-export class BaseNetworkStakeStepRewardService extends
-  AbstractCreatableProvider<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
-  static readonly defaultMoniker = NetworkStakeStepRewardViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [NetworkStakeStepRewardViewerMoniker]
-  override moniker = BaseNetworkStakeStepRewardService.defaultMoniker
-
-  networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, AttoXL1>> {
-    throw new Error('Method [networkStakeStepRewardAddressHistory] not implemented.')
-  }
-
-  networkStakeStepRewardAddressReward(_context: StepIdentity, _address: Address): Promisable<Record<Address, AttoXL1>> {
-    throw new Error('Method [networkStakeStepRewardAddressReward] not implemented.')
-  }
-
-  networkStakeStepRewardAddressShare(_context: StepIdentity, _address: Address): Promisable<[bigint, bigint]> {
-    throw new Error('Method [networkStakeStepRewardAddressShare] not implemented.')
-  }
-
-  networkStakeStepRewardClaimedByAddress(_address: Address): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardClaimedByAddress] not implemented.')
-  }
-
-  networkStakeStepRewardForPosition(_position: number, _range: [number, number]): Promisable<[AttoXL1, AttoXL1]> {
-    throw new Error('Method [networkStakeStepRewardForPosition] not implemented.')
-  }
-
-  networkStakeStepRewardForStep(_context: StepIdentity): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardForStep] not implemented.')
-  }
-
-  networkStakeStepRewardForStepForPosition(_context: StepIdentity, _position: number): Promisable<[AttoXL1, AttoXL1]> {
-    throw new Error('Method [networkStakeStepRewardForStepForPosition] not implemented.')
-  }
-
-  networkStakeStepRewardPoolRewards(_context: StepIdentity): Promisable<Record<Address, AttoXL1>> {
-    throw new Error('Method [networkStakeStepRewardPoolRewards] not implemented.')
-  }
-
-  networkStakeStepRewardPoolShares(_context: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method [networkStakeStepRewardPoolShares] not implemented.')
-  }
-
-  networkStakeStepRewardPositionWeight(_context: StepIdentity, _position: number): Promisable<bigint> {
-    throw new Error('Method [networkStakeStepRewardPositionWeight] not implemented.')
-  }
-
-  networkStakeStepRewardPotentialPositionLoss(_context: StepIdentity, _position: number): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardPotentialPositionLoss] not implemented.')
-  }
-
-  networkStakeStepRewardRandomizer(_context: StepIdentity): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardRandomizer] not implemented.')
-  }
-
-  networkStakeStepRewardStakerCount(_context: StepIdentity): Promisable<number> {
-    throw new Error('Method [networkStakeStepRewardStakerCount] not implemented.')
-  }
-
-  networkStakeStepRewardUnclaimedByAddress(_address: Address): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardUnclaimedByAddress] not implemented.')
-  }
-
-  networkStakeStepRewardWeightForAddress(_context: StepIdentity, _address: Address): Promisable<bigint> {
-    throw new Error('Method [networkStakeStepRewardWeightForAddress] not implemented.')
-  }
-
-  networkStakeStepRewardsForPosition(_position: number, _range: [number, number]): Promisable<Record<StepIdentityString, [AttoXL1, AttoXL1]>> {
-    throw new Error('Method [networkStakeStepRewardsForPosition] not implemented.')
-  }
-
-  networkStakeStepRewardsForRange(_range: [number, number]): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardsForRange] not implemented.')
-  }
-
-  networkStakeStepRewardsForStepLevel(_stepLevel: number, _range: [number, number]): Promisable<AttoXL1> {
-    throw new Error('Method [networkStakeStepRewardsForStepLevel] not implemented.')
-  }
-}

package/src/NetworkStakeStepReward/index.ts

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

package/src/StepStake/BaseStepStakeService.ts

@@ -1,24 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import type { ReadArchivist } from '@xyo-network/sdk-js'
-import type { StepIdentity, StepStakeViewer } from '@xyo-network/xl1-sdk'
-import { AbstractCreatableProvider, StepStakeViewerMoniker } from '@xyo-network/xl1-sdk'
-
-import type { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseStepStakeServiceParams extends BaseServiceParams {
-  chainArchivist: ReadArchivist
-}
-
-export abstract class AbstractStepStakeService extends AbstractCreatableProvider<BaseStepStakeServiceParams> implements StepStakeViewer {
-  static readonly defaultMoniker = StepStakeViewerMoniker
-  static readonly monikers = [StepStakeViewerMoniker]
-  override moniker = AbstractStepStakeService.defaultMoniker
-
-  stepStake(_step: StepIdentity): Promisable<Record<Address, bigint>> {
-    throw new Error('Method [stepStake] not implemented.')
-  }
-
-  stepStakeForAddress(_address: Address, _step: StepIdentity): Promisable<bigint> {
-    throw new Error('Method [stepStakeForAddress] not implemented.')
-  }
-}

package/src/StepStake/index.ts

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

package/src/implementation/head/createBootstrapHead.ts

@@ -1,36 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { buildNextBlock, createGenesisBlock } from '@xyo-network/chain-protocol'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import type {
-  AttoXL1, ChainId, SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-sdk'
-import { createDeclarationIntent } from '@xyo-network/xl1-sdk'
-
-export const createBootstrapHead = async (
-  account: AccountInstance,
-  chainId: ChainId,
-  genesisBlockRewardAmount: AttoXL1,
-  genesisBlockRewardAddress: Address,
-): Promise<SignedHydratedBlockWithHashMeta[]> => {
-  const chain: SignedHydratedBlockWithHashMeta[] = []
-
-  // Create genesis block
-  const genesisBlock = await createGenesisBlock(account, chainId, genesisBlockRewardAmount, genesisBlockRewardAddress)
-  chain.push(genesisBlock)
-
-  // Create producer declaration block
-  const producerDeclarationPayload = createDeclarationIntent(
-    account.address,
-    'producer',
-    genesisBlock[0].block,
-    genesisBlock[0].block + 10_000,
-  )
-  const producerDeclarationBlock = await buildNextBlock(
-    genesisBlock[0],
-    [],
-    [producerDeclarationPayload],
-    [account],
-  )
-  chain.push(producerDeclarationBlock)
-  return chain
-}

package/src/implementation/head/index.ts

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

package/src/implementation/index.ts

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

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './BlockReward/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 './simple/index.ts'
-export * from './StepStake/index.ts'

package/src/model/Params.ts

@@ -1,10 +0,0 @@
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import type { CreatableProviderParams, OpenTelemetryProviders } from '@xyo-network/xl1-sdk'
-
-export interface BaseServiceParams extends CreatableProviderParams, OpenTelemetryProviders {
-
-}
-
-export interface BaseAccountableServiceParams extends BaseServiceParams {
-  account: AccountInstance
-}

package/src/model/index.ts

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

package/src/simple/block/index.ts

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

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

@@ -1,363 +0,0 @@
-import {
-  Address, assertEx, exists, Hex, hexToBigInt, isDefined, Promisable,
-} from '@xylabs/sdk-js'
-import {
-  BlockRewardDiviner, FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema,
-} from '@xyo-network/chain-modules'
-import { buildNextBlock } from '@xyo-network/chain-protocol'
-import {
-  AccountInstance,
-  ArchivistInstance, MemoryArchivist,
-  PayloadBuilder, WithHashMeta,
-} from '@xyo-network/sdk-js'
-import {
-  AbstractCreatableProvider, AccountBalanceViewer, AccountBalanceViewerMoniker, AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness,
-  BlockNumberPayload, BlockNumberSchema, BlockRewardViewer, BlockRewardViewerMoniker, BlockRunner, BlockRunnerMoniker, BlockValidationViewer,
-  BlockValidationViewerMoniker, ChainStakeIntent, creatableProvider, CreatableProviderParams, createDeclarationIntent, defaultRewardRatio,
-  FinalizationViewer,
-  FinalizationViewerMoniker,
-  HydratedBlockStateValidationFunction, isSignedHydratedBlockWithHashMeta, MempoolRunner, MempoolRunnerMoniker, MempoolViewer, MempoolViewerMoniker,
-  SignedBlockBoundWitnessWithHashMeta,
-  SignedHydratedBlockWithHashMeta, SignedHydratedTransaction, TimeSyncViewer, TimeSyncViewerMoniker, Transfer, XYO_STEP_REWARD_ADDRESS,
-} from '@xyo-network/xl1-sdk'
-
-import { generateTransactionFeeTransfers } from './generateTransactionFeeTransfers.ts'
-
-/**
- * The default block size for a block
- */
-export const DEFAULT_BLOCK_SIZE = 10
-
-/**
- * The amount of time for which a producer will restake their intent
- */
-export const XYO_PRODUCER_REDECLARATION_DURATION = 10_000
-
-/**
- * The number of blocks within which a producer will redeclare
- * their intent to produce blocks
- */
-export const XYO_PRODUCER_REDECLARATION_WINDOW = 500
-
-export interface SimpleBlockRunnerParams extends CreatableProviderParams {
-  account: AccountInstance
-  disableIntentRedeclaration?: boolean
-  heartbeatInterval?: number
-  rejectedTransactionsArchivist?: ArchivistInstance
-  rewardAddress: Address
-  validateHydratedBlockState?: HydratedBlockStateValidationFunction
-}
-
-@creatableProvider()
-export class SimpleBlockRunner extends AbstractCreatableProvider<SimpleBlockRunnerParams> implements BlockRunner {
-  static readonly defaultMoniker = BlockRunnerMoniker
-  static readonly dependencies = [
-    AccountBalanceViewerMoniker,
-    BlockRewardViewerMoniker,
-    BlockValidationViewerMoniker,
-    FinalizationViewerMoniker,
-    MempoolRunnerMoniker,
-    MempoolViewerMoniker,
-    TimeSyncViewerMoniker,
-  ]
-
-  static readonly monikers = [BlockRunnerMoniker]
-  moniker = SimpleBlockRunner.defaultMoniker
-
-  protected _blockRewardDiviner?: BlockRewardDiviner
-  protected _lastRedeclarationBlock?: number
-  protected _rejectedTransactionsArchivist?: ArchivistInstance
-
-  private _account?: AccountInstance
-  private _accountBalanceViewer?: AccountBalanceViewer
-  private _address?: Address
-  private _blockRewardViewer?: BlockRewardViewer
-  private _blockValidationViewer?: BlockValidationViewer
-  private _finalizationViewer?: FinalizationViewer
-  private _mempoolRunner?: MempoolRunner
-  private _mempoolViewer?: MempoolViewer
-  private _rewardAddress?: Address
-  private _timeSyncViewer?: TimeSyncViewer
-
-  /**
-   * The default block size for a block
-   */
-  static get DefaultBlockSize(): number {
-    return DEFAULT_BLOCK_SIZE
-  }
-
-  /**
-   * The amount of time for which the producer will redeclare
-   * their intent to continue producing blocks
-   */
-  static get RedeclarationDuration(): number {
-    return XYO_PRODUCER_REDECLARATION_DURATION
-  }
-
-  /**
-   * The number of blocks within which the producer will redeclare
-   * their intent to continue producing blocks
-   */
-  static get RedeclarationWindow(): number {
-    return XYO_PRODUCER_REDECLARATION_WINDOW
-  }
-
-  protected get account() {
-    return this._account!
-  }
-
-  protected get accountBalanceViewer() {
-    return this._accountBalanceViewer!
-  }
-
-  protected get address() {
-    return this._address!
-  }
-
-  protected get blockRewardViewer() {
-    return this._blockRewardViewer!
-  }
-
-  protected get blockValidationViewer() {
-    return this._blockValidationViewer!
-  }
-
-  protected get finalizationViewer() {
-    return this._finalizationViewer!
-  }
-
-  protected get heartbeatInterval() {
-    return this.params.heartbeatInterval ?? 3_600_000
-  }
-
-  protected get mempoolRunner() {
-    return this._mempoolRunner!
-  }
-
-  protected get mempoolViewer() {
-    return this._mempoolViewer!
-  }
-
-  // protected get pendingTransactionsService() {
-  //   return assertEx(this.params.pendingTransactionsService, () => 'Missing pendingTransactionsService')
-  // }
-
-  protected get rejectedTransactionsArchivist() {
-    return this._rejectedTransactionsArchivist!
-  }
-
-  protected get rewardAddress(): Address {
-    return this._rewardAddress!
-  }
-
-  // protected get stakeIntentService(): StakeIntentService {
-  //   return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
-  // }
-
-  protected get timeSyncViewer(): TimeSyncViewer {
-    return this._timeSyncViewer!
-  }
-
-  // protected get validateHydratedBlockState() {
-  //   return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
-  // }
-
-  override async createHandler() {
-    this._rejectedTransactionsArchivist = this.params.rejectedTransactionsArchivist ?? await MemoryArchivist.create()
-    this._account = assertEx(this.params.account, () => 'Account is required')
-    this._address = this.account.address
-    this._accountBalanceViewer = await this.locateAndCreate<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._blockRewardViewer = await this.locateAndCreate<BlockRewardViewer>(BlockRewardViewerMoniker)
-    this._blockValidationViewer = await this.locator.getInstance<BlockValidationViewer>(BlockValidationViewerMoniker)
-    this._finalizationViewer = await this.locateAndCreate<FinalizationViewer>(FinalizationViewerMoniker)
-    this._mempoolRunner = await this.locateAndCreate<MempoolRunner>(MempoolRunnerMoniker)
-    this._mempoolViewer = await this.locateAndCreate<MempoolViewer>(MempoolViewerMoniker)
-    this._rewardAddress = this.params.rewardAddress
-    this._timeSyncViewer = await this.locateAndCreate<TimeSyncViewer>(TimeSyncViewerMoniker)
-  }
-
-  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(', ')}`)
-    // }
-    // 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 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[]> {
-    if (!this._blockRewardDiviner) {
-      // TODO: Adjust to allow for genesis block reward vs. normal block reward
-      this._blockRewardDiviner = await FixedPercentageBlockRewardDiviner.create({
-        account: 'random',
-        blockRewardViewer: this.blockRewardViewer,
-        config: {
-          rewardAddress: this.rewardAddress,
-          rewardPercentageRatio: defaultRewardRatio,
-          schema: FixedPercentageBlockRewardDivinerConfigSchema,
-        },
-      })
-    }
-
-    const blockId = new PayloadBuilder<BlockNumberPayload>({ schema: BlockNumberSchema }).fields({ block }).build()
-    const rewards = await this._blockRewardDiviner.divine([blockId])
-    return rewards as Transfer[]
-  }
-
-  /**
-   * Handles the producer redeclaration logic
-   * @param head The current head block
-   * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
-   */
-  protected getProducerRedeclaration(head: WithHashMeta<BlockBoundWitness>): Promisable<ChainStakeIntent | undefined> {
-    // TODO: Do not redeclare on every block
-    // Decide if we should redeclare intent
-    if (this.params.disableIntentRedeclaration) return
-    // Decide if we need to redeclare intent
-    // 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 currentBlock = head.block
-    // 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, force = false) {
-    // eslint-disable-next-line max-statements
-    return await this.spanAsync('proposeNextValidBlock', async () => {
-      try {
-      // Calculate the next block components
-        const { block: previousBlock } = assertEx(asBlockBoundWitness(head), () => 'Invalid head block')
-        const nextBlock = previousBlock + 1
-        const nextBlockTransactions = await this.mempoolViewer.pendingTransactions({ limit: SimpleBlockRunner.DefaultBlockSize })
-
-        this.logger?.info(`Pending Tx Count ${nextBlockTransactions.length}`)
-
-        const blockPayloads: AllowedBlockPayload[] = []
-
-        // Calculate the optional producer redeclaration and add it if necessary
-        const producerRedeclarationPayload = await this.getProducerRedeclaration(head)
-        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 (nextBlockTransactions.length === 0 && !this.heartbeatRequired(head) && !force) return
-
-        // Calculate the optional block reward transfer and add if necessary
-        const rewardTransferPayloads = await this.getBlockRewardTransfers(nextBlock)
-        blockPayloads.push(...rewardTransferPayloads)
-
-        const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions)
-        const timeStart = Date.now()
-        const timePayload = await this.generateTimePayload()
-        const timeDuration = Date.now() - timeStart
-        if (timeDuration > 100) {
-          this.logger?.warn(`[Slow] Generated time payload in ${timeDuration}ms`)
-        }
-
-        const [fundedNextBlockTransactions, fundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances)
-
-        blockPayloads.push(...fundedTransfers, timePayload)
-
-        // Build the block
-        this.logger?.info(`Building block ${head.block + 1}`)
-        const startBuild = Date.now()
-        const stepRewardPoolBalance = (await this.accountBalanceViewer.accountBalances([XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS]
-        const block = await buildNextBlock(
-          head,
-          fundedNextBlockTransactions,
-          blockPayloads,
-          [this.account],
-          XYO_STEP_REWARD_ADDRESS,
-          stepRewardPoolBalance,
-          undefined,
-          await this.finalizationViewer.chainId(),
-        )
-
-        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 validatedBlock = await this.blockValidationViewer.validateBlock(block, { head: head._hash })
-        this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`)
-
-        if (isSignedHydratedBlockWithHashMeta(validatedBlock)) {
-          await this.mempoolRunner.submitBlocks([validatedBlock])
-          return validatedBlock
-        } else {
-          const errors = validatedBlock
-          this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`)
-          const rejectedTransactions = block[1]
-          await this.rejectedTransactionsArchivist.insert(rejectedTransactions)
-        }
-      } catch (error) {
-        this.logger?.error(`Error proposing next valid block: ${(error as Error).message}`)
-        throw error
-      }
-    }, this.context)
-  }
-
-  // remove unfunded transactions and block transfers
-  private async filterByFunded(
-    head: WithHashMeta<BlockBoundWitness>,
-    txs: SignedHydratedTransaction[],
-    transfers: Transfer[],
-    validateBalances = false,
-  ): Promise<[SignedHydratedTransaction[], Transfer[]]> {
-    const fundedTransfers: Transfer[] = []
-    const fundedTransactions = (await Promise.all(txs.map(async (tx) => {
-      const transfer: Transfer | undefined = transfers.find(transfer => transfer.from === tx[0].from)
-      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.accountBalanceViewer.accountBalances([transfer.from]))[transfer.from] ?? AttoXL1(0n)
-        if (balance >= totalTransferCost) {
-          fundedTransfers.push(transfer)
-          return tx
-        }
-      } else {
-        fundedTransfers.push(transfer)
-        return tx
-      }
-    }))).filter(exists)
-    return [fundedTransactions, fundedTransfers]
-  }
-
-  private async generateTimePayload() {
-    return await this.timeSyncViewer.currentTimePayload()
-  }
-
-  /**
-   * Check if a heartbeat block is required based on network activity.
-   * @param head The current head block
-   * @returns True if a heartbeat is required, false otherwise
-   */
-  private heartbeatRequired(head: WithHashMeta<BlockBoundWitness>): boolean {
-    const epoch = head.$epoch
-    if (isDefined(epoch) && Date.now() - epoch > this.heartbeatInterval) {
-      return true
-    }
-    return false
-  }
-}