@xyo-network/chain-orchestration 1.19.2 → 1.19.4

package/src/actor/MempoolActor.ts

@@ -0,0 +1,105 @@
+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
+  }
+}

package/src/actor/ValidatorActor.ts

@@ -9,27 +9,24 @@ import {
   Actor,
   ActorParams,
   BlockViewer,
-  BlockViewerMoniker,
-  MempoolViewer, MempoolViewerMoniker,
+  MempoolViewer,
 } from '@xyo-network/xl1-sdk'
 
 export type ValidatorActorParams = ActorParams<
   {
     account: AccountInstance
-    blockViewer?: BlockViewer
+    blockViewer: BlockViewer
     finalizedArchivist: ArchivistInstance
-    mempoolViewer?: MempoolViewer
+    mempoolViewer: MempoolViewer
   }>
 
 @creatable()
 export class ValidatorActor extends Actor<ValidatorActorParams> {
-  protected _blockViewer: BlockViewer | undefined
   protected _lastValidatedBlock: BlockBoundWitness | undefined
   protected _lastValidatedBlockHash: Hash | undefined
-  protected _mempoolViewer: MempoolViewer | undefined
 
   protected get blockViewer() {
-    return this._blockViewer!
+    return this.params.blockViewer
   }
 
   protected get finalizedArchivist() {
@@ -37,21 +34,29 @@ export class ValidatorActor extends Actor<ValidatorActorParams> {
   }
 
   protected get mempoolViewer() {
-    return this._mempoolViewer!
+    return this.params.mempoolViewer
   }
 
-  override async createHandler() {
-    await super.createHandler()
-
-    this._blockViewer = assertEx(
-      this.params.blockViewer ?? await this.locator?.getInstance<BlockViewer>(BlockViewerMoniker),
-      () => 'Unable to locate a BlockViewer',
-    )
-
-    this._mempoolViewer = assertEx(
-      this.params.mempoolViewer ?? await this.locator?.getInstance<MempoolViewer>(MempoolViewerMoniker),
-      () => 'Unable to locate a 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 startHandler(): Promise<void> {

package/src/actor/index.ts

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