@xyo-network/chain-orchestration 1.19.7 → 1.19.9

package/src/actor/ValidatorActor.ts

@@ -1,62 +1,46 @@
 import type { Hash } from '@xylabs/sdk-js'
-import { assertEx, creatable } from '@xylabs/sdk-js'
-import { AccountInstance } from '@xyo-network/account-model'
-import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { creatable } from '@xylabs/sdk-js'
 import { processPendingBlocks } from '@xyo-network/chain-sdk'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { BlockBoundWitness } from '@xyo-network/xl1-sdk'
-import {
-  Actor,
-  ActorParams,
-  BlockViewer,
+import type {
+  ActorParamsV3, BlockBoundWitness, BlockViewer, Config,
+  FinalizationRunner,
   MempoolViewer,
 } from '@xyo-network/xl1-sdk'
+import {
+  ActorV3, BlockViewerMoniker, FinalizationRunnerMoniker,
+  MempoolViewerMoniker,
+} from '@xyo-network/xl1-sdk'
 
-export type ValidatorActorParams = ActorParams<
+export type ValidatorActorParams = ActorParamsV3<
   {
-    account: AccountInstance
-    blockViewer: BlockViewer
-    finalizedArchivist: ArchivistInstance
-    mempoolViewer: MempoolViewer
+    config: Config
   }>
 
 @creatable()
-export class ValidatorActor extends Actor<ValidatorActorParams> {
+export class ValidatorActor extends ActorV3<ValidatorActorParams> {
+  protected _blockViewer!: BlockViewer
+  protected _finalizationRunner!: FinalizationRunner
   protected _lastValidatedBlock: BlockBoundWitness | undefined
   protected _lastValidatedBlockHash: Hash | undefined
+  protected _mempoolViewer!: MempoolViewer
 
   protected get blockViewer() {
-    return this.params.blockViewer
+    return this._blockViewer
   }
 
-  protected get finalizedArchivist() {
-    return assertEx(this.params.finalizedArchivist, () => 'finalizedArchivist not set')
+  protected get finalizationRunner() {
+    return this._finalizationRunner
   }
 
   protected get mempoolViewer() {
-    return this.params.mempoolViewer
+    return this._mempoolViewer
   }
 
-  static override async paramsHandler(params?: Partial<ValidatorActorParams>) {
-    return {
-      ...await super.paramsHandler(params),
-      mempoolViewer: assertEx(
-        params?.mempoolViewer,
-        () => 'mempoolViewer is required for ValidatorActor',
-      ),
-      blockViewer: assertEx(
-        params?.blockViewer,
-        () => 'blockViewer is required for ValidatorActor',
-      ),
-      finalizedArchivist: assertEx(
-        params?.finalizedArchivist,
-        () => 'finalizedArchivist is required for ValidatorActor',
-      ),
-      account: assertEx(
-        params?.account,
-        () => 'account is required for ValidatorActor',
-      ),
-    } satisfies ValidatorActorParams
+  override async createHandler() {
+    await super.startHandler()
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
+    this._finalizationRunner = await this.locator.getInstance(FinalizationRunnerMoniker)
+    this._mempoolViewer = await this.locator.getInstance(MempoolViewerMoniker)
   }
 
   override async startHandler(): Promise<void> {
@@ -69,26 +53,9 @@ export class ValidatorActor extends Actor<ValidatorActorParams> {
           logger: this.logger,
           mempoolViewer: this.mempoolViewer,
           blockViewer: this.blockViewer,
-          finalizedArchivist: this.finalizedArchivist,
+          finalizationRunner: this.finalizationRunner,
         })
       }, { ...this.context, timeBudgetLimit: 1500 })
     }, 2000, 1500/* 500 */)
   }
-
-  protected async slashInvalidBlock(_block: BlockBoundWitness): Promise<boolean> {
-    // TODO: Handle slashing logic
-    const slashed = await Promise.resolve(true)
-    return slashed
-  }
-
-  protected async validateBlock(block: BlockBoundWitness): Promise<boolean> {
-    // TODO: Validate using validation logic
-    const valid = await Promise.resolve(true)
-    // Store the last validated block and its hash
-    this._lastValidatedBlock = block
-    this._lastValidatedBlockHash = await PayloadBuilder.hash(block)
-
-    // Return the validation result
-    return valid
-  }
 }

package/src/actor/index.ts

@@ -1,3 +1 @@
-export * from './BalanceActor.ts'
-export * from './MempoolActor.ts'
 export * from './ValidatorActor.ts'

package/src/health/initHealthEndpoints.ts

@@ -65,6 +65,6 @@ export const initHealthEndpoints: Initializable<{ config: Config; logger: Logger
   const {
     config, logger, statusReporter,
   } = params
-  const { healthCheckPort } = config.producer
+  const { healthCheckPort } = config.actors.producer
   return isDefined(healthCheckPort) ? createHealthServer(healthCheckPort, statusReporter, logger) : undefined
 }

package/src/init/index.ts

@@ -1,6 +1,7 @@
 export * from './initBalanceSummaryMap.ts'
 export * from './initBridgedModule.ts'
 export * from './initEvmProvidersIfAvailable.ts'
+export * from './initFinalizationArchivistIfNeeded.ts'
 export * from './initFinalizedArchivist.ts'
 export * from './initProducerAccount.ts'
 export * from './initSeedPhrase.ts'

package/src/init/initEvmProvidersIfAvailable.ts

@@ -1,6 +1,6 @@
 import { asEthAddress, assertEx } from '@xylabs/sdk-js'
 import {
-  EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeViewer,
+  EvmChainContractViewer, EvmStakeEventsViewer, EvmStakeTotalsViewer, EvmStakeViewer,
 } from '@xyo-network/chain-ethereum'
 import type {
   ChainId,
@@ -9,7 +9,7 @@ import type {
 } from '@xyo-network/xl1-sdk'
 import {
   SimpleChainContractViewer,
-  SimpleStakeEventsViewer, SimpleStakeViewer, SimpleTimeSyncViewer,
+  SimpleStakeEventsViewer, SimpleStakeTotalsViewer, SimpleStakeViewer, SimpleTimeSyncViewer,
   XYO_ZERO_ADDRESS,
 } from '@xyo-network/xl1-sdk'
 
@@ -34,6 +34,12 @@ export async function initEvmProvidersIfAvailable(locator: ProviderFactoryLocato
       { address, provider },
     ))
 
+    // Register the stake totals viewer
+    locator.register(EvmStakeTotalsViewer.factory<EvmStakeTotalsViewer>(
+      EvmStakeTotalsViewer.dependencies,
+      { address, provider },
+    ))
+
     // Register the contract viewer
     locator.register(EvmChainContractViewer.factory<EvmChainContractViewer>(
       EvmChainContractViewer.dependencies,
@@ -61,6 +67,12 @@ export async function initEvmProvidersIfAvailable(locator: ProviderFactoryLocato
       { positions },
     ))
 
+    // Register the stake totals viewer
+    locator.register(SimpleStakeTotalsViewer.factory<SimpleStakeTotalsViewer>(
+      SimpleStakeTotalsViewer.dependencies,
+      {},
+    ))
+
     // Register the contract viewer
     locator.register(SimpleChainContractViewer.factory<SimpleChainContractViewer>(
       SimpleChainContractViewer.dependencies,

package/src/init/initFinalizationArchivistIfNeeded.ts

@@ -0,0 +1,42 @@
+import { assertEx } from '@xylabs/sdk-js'
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { createBootstrapHead } from '@xyo-network/chain-sdk'
+import {
+  asAttoXL1,
+  type ChainId, type Config, findMostRecentBlock,
+  flattenHydratedBlock,
+  type SignedBlockBoundWitnessWithHashMeta,
+} from '@xyo-network/xl1-sdk'
+
+export async function initFinalizationArchivistIfNeeded(
+  archivist: ArchivistInstance,
+  config: Config,
+  account: AccountInstance,
+): Promise<[SignedBlockBoundWitnessWithHashMeta, ChainId]> {
+  const configuredChainId = config.chain.id
+  const possibleHead = await findMostRecentBlock(archivist)
+  if (configuredChainId && possibleHead && possibleHead.chain !== configuredChainId) {
+    throw new Error(`Configured chain ID (${configuredChainId}) does not match the existing chain ID (${possibleHead.chain})`)
+  }
+
+  let possibleChainId: ChainId | undefined = configuredChainId
+
+  // if there is no configured chain ID and no head, create a new chain
+  if (!possibleHead) {
+    possibleChainId = possibleChainId ?? (await Account.random()).address
+    // If there is no head, create one
+    const chain = await createBootstrapHead(
+      account,
+      possibleChainId,
+      asAttoXL1(20_000_000_000_000_000_000_000n),
+      config.chain.genesisRewardAddress ?? account.address,
+    )
+    const payloads = chain.flatMap(block => flattenHydratedBlock(block))
+    await archivist.insert(payloads)
+  }
+  const head = possibleHead ?? assertEx(await findMostRecentBlock(archivist), () => 'No blocks found in chain archivist')
+  const chainId = assertEx(possibleChainId, () => 'Chain ID could not be determined')
+  return [head, chainId]
+}

package/src/init/initProducerAccount.ts

@@ -12,7 +12,7 @@ let accountServiceSingleton: Promisable<WalletInstance> | undefined
 export const initProducerAccount: Initializable<InitializableParams<{ config: Config }>, WalletInstance>
   = async ({ config, logger }): Promise<WalletInstance> => {
     if (accountServiceSingleton) return accountServiceSingleton
-    let walletPhrase = config.producer.mnemonic
+    let walletPhrase = config.actors.producer.mnemonic
     if (isUndefined(walletPhrase)) {
       logger?.warn('[Producer] No wallet mnemonic specified!')
       const randomMnemonic = HDWallet.generateMnemonic()

package/src/init/initSeedPhrase.ts

@@ -10,7 +10,7 @@ export async function initSeedPhrase({
 }: ConfigContext<{ bios: BiosExternalInterface }>): Promise<string> {
   const storedSeedPhrase = await bios.seedPhraseStore.get('os')
   logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`)
-  const { mnemonic } = config.api
+  const { mnemonic } = config.actors.api
   if (isString(storedSeedPhrase) && isString(mnemonic)) {
     logger?.warn('[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.')
     await bios.seedPhraseStore.set('os', mnemonic)

package/src/init/initWallet.ts

@@ -16,21 +16,31 @@ async function initWallet({ config, logger }: ConfigContext, mnemonic?: string)
 }
 
 export async function initApiWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.api
+  const { mnemonic } = config.actors.api
+  return await initWallet({ config, logger }, mnemonic)
+}
+
+export async function initBridgeWallet({ config, logger }: ConfigContext) {
+  const { mnemonic } = config.actors.bridge
   return await initWallet({ config, logger }, mnemonic)
 }
 
 export async function initMempoolWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.mempool
+  const { mnemonic } = config.actors.mempool
   return await initWallet({ config, logger }, mnemonic)
 }
 
 export async function initProducerWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.producer
+  const { mnemonic } = config.actors.producer
   return await initWallet({ config, logger }, mnemonic)
 }
 
 export async function initRewardsRedemptionApiWallet({ config, logger }: ConfigContext) {
-  const { mnemonic } = config.rewardRedemptionApi
+  const { mnemonic } = config.actors.rewardRedemption
+  return await initWallet({ config, logger }, mnemonic)
+}
+
+export async function initValidatorWallet({ config, logger }: ConfigContext) {
+  const { mnemonic } = config.actors.mempool
   return await initWallet({ config, logger }, mnemonic)
 }

package/src/orchestrator/Orchestrator.ts

@@ -1,14 +1,16 @@
 import type { CreatableInstance } from '@xylabs/sdk-js'
 import { AbstractCreatable, creatable } from '@xylabs/sdk-js'
-import { ActorInstance, ActorInstanceV2 } from '@xyo-network/xl1-sdk'
+import {
+  ActorInstance, ActorInstanceV2, ActorInstanceV3,
+} from '@xyo-network/xl1-sdk'
 
 export interface OrchestratorInstance extends CreatableInstance {
-  registerActor(actor: ActorInstance | ActorInstanceV2): Promise<void>
+  registerActor(actor: ActorInstance | ActorInstanceV2 | ActorInstanceV3): Promise<void>
 }
 
 @creatable()
 export class Orchestrator extends AbstractCreatable implements OrchestratorInstance {
-  protected actors: (ActorInstance | ActorInstanceV2)[] = []
+  protected actors: (ActorInstance | ActorInstanceV2 | ActorInstanceV3)[] = []
   protected keepAliveHandle: NodeJS.Timeout | null = null
   protected running = false
 
@@ -16,7 +18,7 @@ export class Orchestrator extends AbstractCreatable implements OrchestratorInsta
    * Registers an actor.
    * (We won't activate the actor until `start()` is called.)
    */
-  async registerActor(actor: ActorInstance | ActorInstanceV2) {
+  async registerActor(actor: ActorInstance | ActorInstanceV2 | ActorInstanceV3) {
     if (this.running) {
       // If the orchestrator is already running, activate the actor immediately
       await actor.start()

package/dist/neutral/actor/BalanceActor.d.ts

@@ -1,17 +0,0 @@
-import type { AccountBalanceViewer, ActorParams, BlockViewer, Config } from '@xyo-network/xl1-sdk';
-import { Actor } from '@xyo-network/xl1-sdk';
-import { Mutex } from 'async-mutex';
-export type BalanceActorParams = ActorParams<{
-    accountBalanceViewer: AccountBalanceViewer;
-    blockViewer: BlockViewer;
-} & {
-    config: Config;
-}>;
-export declare class BalanceActor extends Actor<BalanceActorParams> {
-    protected _updateMutex: Mutex;
-    protected get accountBalanceViewer(): AccountBalanceViewer;
-    protected get blockViewer(): BlockViewer<"BlockViewer">;
-    startHandler(): Promise<void>;
-    protected updateBalance(): Promise<void>;
-}
-//# sourceMappingURL=BalanceActor.d.ts.map

package/dist/neutral/actor/BalanceActor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BalanceActor.d.ts","sourceRoot":"","sources":["../../../src/actor/BalanceActor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,WAAW,EAAE,WAAW,EAAE,MAAM,EACjC,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAC1C;IACE,oBAAoB,EAAE,oBAAoB,CAAA;IAC1C,WAAW,EAAE,WAAW,CAAA;CACzB,GACC;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAEvB,qBAAa,YAAa,SAAQ,KAAK,CAAC,kBAAkB,CAAC;IACzD,SAAS,CAAC,YAAY,QAAc;IAEpC,SAAS,KAAK,oBAAoB,yBAEjC;IAED,SAAS,KAAK,WAAW,+BAExB;IAEc,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;cAO5B,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;CAO/C"}

package/dist/neutral/actor/MempoolActor.d.ts

@@ -1,41 +0,0 @@
-import { ArchivistInstance } from '@xyo-network/archivist-model';
-import { Actor, ActorParams, MempoolRunner } from '@xyo-network/xl1-sdk';
-export type MempoolActorParams = ActorParams<{
-    mempoolRunner: MempoolRunner;
-    pendingBlocksArchivist: ArchivistInstance;
-    pendingTransactionsArchivist: ArchivistInstance;
-}>;
-export declare class MempoolActor extends Actor<MempoolActorParams> {
-    private _blockTimerId;
-    private _blockTimerMutex;
-    private _transactionTimerId;
-    private _transactionTimerMutex;
-    protected get mempoolRunner(): MempoolRunner;
-    protected get pendingBlocksArchivist(): ArchivistInstance<import("@xyo-network/archivist-model").ArchivistParams<import("@xyo-network/module-model").AnyConfigSchema<import("@xyo-network/archivist-model").ArchivistConfig>>, import("@xyo-network/archivist-model").ArchivistModuleEventData, import("@xyo-network/payload-model").Payload>;
-    protected get pendingTransactionsArchivist(): ArchivistInstance<import("@xyo-network/archivist-model").ArchivistParams<import("@xyo-network/module-model").AnyConfigSchema<import("@xyo-network/archivist-model").ArchivistConfig>>, import("@xyo-network/archivist-model").ArchivistModuleEventData, import("@xyo-network/payload-model").Payload>;
-    static paramsHandler(params?: Partial<MempoolActorParams>): Promise<{
-        mempoolRunner: MempoolRunner;
-        pendingBlocksArchivist: ArchivistInstance<import("@xyo-network/archivist-model").ArchivistParams<import("@xyo-network/module-model").AnyConfigSchema<import("@xyo-network/archivist-model").ArchivistConfig>>, import("@xyo-network/archivist-model").ArchivistModuleEventData, import("@xyo-network/payload-model").Payload>;
-        pendingTransactionsArchivist: ArchivistInstance<import("@xyo-network/archivist-model").ArchivistParams<import("@xyo-network/module-model").AnyConfigSchema<import("@xyo-network/archivist-model").ArchivistConfig>>, import("@xyo-network/archivist-model").ArchivistModuleEventData, import("@xyo-network/payload-model").Payload>;
-        name?: import("@xylabs/sdk-js").CreatableName;
-        statusReporter?: import("@xylabs/sdk-js").CreatableStatusReporter<void> | undefined;
-        logger: import("@xylabs/sdk-js").Logger;
-        meterProvider?: import("@opentelemetry/api").MeterProvider;
-        traceProvider?: import("@opentelemetry/api").TracerProvider;
-        account: import("@xyo-network/account-model").AccountInstance;
-        context: import("@xyo-network/xl1-sdk").ActorContext;
-        displayName: string | (string & {
-            __baseClassName: true;
-        }) | undefined;
-        id: string | (string & {
-            __baseClassName: true;
-        });
-    }>;
-    startHandler(): Promise<void>;
-    stopHandler(): Promise<void>;
-    private restartBlockTimer;
-    private restartTransactionTimer;
-    private stopBlockTimer;
-    private stopTransactionTimer;
-}
-//# sourceMappingURL=MempoolActor.d.ts.map

package/dist/neutral/actor/MempoolActor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MempoolActor.d.ts","sourceRoot":"","sources":["../../../src/actor/MempoolActor.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,EACL,KAAK,EAAE,WAAW,EAClB,aAAa,EACd,MAAM,sBAAsB,CAAA;AAG7B,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC;IAC3C,aAAa,EAAE,aAAa,CAAA;IAC5B,sBAAsB,EAAE,iBAAiB,CAAA;IACzC,4BAA4B,EAAE,iBAAiB,CAAA;CAChD,CAAC,CAAA;AAEF,qBACa,YAAa,SAAQ,KAAK,CAAC,kBAAkB,CAAC;IACzD,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,gBAAgB,CAAc;IAEtC,OAAO,CAAC,mBAAmB,CAA8C;IACzE,OAAO,CAAC,sBAAsB,CAAc;IAE5C,SAAS,KAAK,aAAa,kBAE1B;IAED,SAAS,KAAK,sBAAsB,0SAEnC;IAED,SAAS,KAAK,4BAA4B,0SAEzC;WAEqB,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;IAkBzD,YAAY;IAMZ,WAAW;IAM1B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,oBAAoB;CAM7B"}

package/src/actor/BalanceActor.ts

@@ -1,41 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  AccountBalanceViewer,
-  ActorParams, BlockViewer, Config,
-} from '@xyo-network/xl1-sdk'
-import { Actor } from '@xyo-network/xl1-sdk'
-import { Mutex } from 'async-mutex'
-
-export type BalanceActorParams = ActorParams<
-  {
-    accountBalanceViewer: AccountBalanceViewer
-    blockViewer: BlockViewer
-  }
-  & { config: Config }>
-
-export class BalanceActor extends Actor<BalanceActorParams> {
-  protected _updateMutex = new Mutex()
-
-  protected get accountBalanceViewer() {
-    return assertEx(this.params.accountBalanceViewer, () => 'balanceService not set')
-  }
-
-  protected get blockViewer() {
-    return assertEx(this.params.blockViewer, () => 'blockViewer not set')
-  }
-
-  override async startHandler(): Promise<void> {
-    await super.startHandler()
-    this.registerTimer('BalanceTimer', async () => {
-      await this.updateBalance()
-    }, 1000, 10_000/* 1000 */)
-  }
-
-  protected async updateBalance(): Promise<void> {
-    if (this._updateMutex.isLocked()) return
-    await this._updateMutex.runExclusive(async () => {
-      const head = await this.blockViewer.currentBlockHash()
-      await this.accountBalanceViewer.accountBalances([], { head })
-    })
-  }
-}

package/src/actor/MempoolActor.ts

@@ -1,105 +0,0 @@
-import {
-  assertEx,
-  creatable,
-} from '@xylabs/sdk-js'
-import { ArchivistInstance } from '@xyo-network/archivist-model'
-import {
-  Actor, ActorParams,
-  MempoolRunner,
-} from '@xyo-network/xl1-sdk'
-import { Mutex } from 'async-mutex'
-
-export type MempoolActorParams = ActorParams<{
-  mempoolRunner: MempoolRunner
-  pendingBlocksArchivist: ArchivistInstance
-  pendingTransactionsArchivist: ArchivistInstance
-}>
-
-@creatable()
-export class MempoolActor extends Actor<MempoolActorParams> {
-  private _blockTimerId: ReturnType<typeof setInterval> | null = null
-  private _blockTimerMutex = new Mutex()
-
-  private _transactionTimerId: ReturnType<typeof setInterval> | null = null
-  private _transactionTimerMutex = new Mutex()
-
-  protected get mempoolRunner() {
-    return this.params.mempoolRunner
-  }
-
-  protected get pendingBlocksArchivist() {
-    return this.params.pendingBlocksArchivist
-  }
-
-  protected get pendingTransactionsArchivist() {
-    return this.params.pendingTransactionsArchivist
-  }
-
-  static override async paramsHandler(params?: Partial<MempoolActorParams>) {
-    return {
-      ...await super.paramsHandler(params),
-      mempoolRunner: assertEx(
-        params?.mempoolRunner,
-        () => 'mempoolRunner is required for MempoolActor',
-      ),
-      pendingBlocksArchivist: assertEx(
-        params?.pendingBlocksArchivist,
-        () => 'pendingBlocksArchivist is required for MempoolActor',
-      ),
-      pendingTransactionsArchivist: assertEx(
-        params?.pendingTransactionsArchivist,
-        () => 'pendingTransactionsArchivist is required for MempoolActor',
-      ),
-    } satisfies MempoolActorParams
-  }
-
-  override async startHandler() {
-    await super.startHandler()
-    // this.restartTransactionTimer()
-    this.restartBlockTimer()
-  }
-
-  override async stopHandler() {
-    await super.stopHandler()
-    // this.stopTransactionTimer()
-    this.stopBlockTimer()
-  }
-
-  private restartBlockTimer() {
-    this.stopBlockTimer()
-    this._blockTimerId = setInterval(() => {
-      if (this._blockTimerMutex.isLocked()) {
-        return
-      }
-      void this._blockTimerMutex.runExclusive(async () => {
-        await this.mempoolRunner.prunePendingBlocks({ batchSize: 50 })
-      })
-    }, 1000)
-  }
-
-  private restartTransactionTimer() {
-    this.stopTransactionTimer()
-    this._transactionTimerId = setInterval(() => {
-      if (this._transactionTimerMutex.isLocked()) {
-        return
-      }
-      void this._transactionTimerMutex.runExclusive(async () => {
-        await this.mempoolRunner.prunePendingTransactions({ batchSize: 50 })
-      })
-    }, 1000)
-  }
-
-  private stopBlockTimer() {
-    if (this._blockTimerId !== null) {
-      clearInterval(this._blockTimerId)
-    }
-    this._blockTimerId = null
-  }
-
-  private stopTransactionTimer() {
-    if (this._transactionTimerId !== null) {
-      clearInterval(this._transactionTimerId)
-    }
-    this._transactionTimerId = null
-  }
-}