feat(txm): added on new block hook

Author: GabrielMartinezRodriguez

packages/randomness-service/src/index.ts

@@ -37,6 +37,7 @@ class RandomnessService {
     async start() {
         await Promise.all([this.txm.start(), this.randomnessRepository.start()])
         this.txm.addHook(this.onTransactionStatusChange.bind(this), TxmHookType.TransactionStatusChanged)
+        this.txm.addHook(this.onNewBlock.bind(this), TxmHookType.NewBlock)
     }
 
     private onTransactionStatusChange(payload: { transaction: Transaction }) {
@@ -70,6 +71,15 @@ class RandomnessService {
         }
     }
 
+    private async onNewBlock(payload: { block: LatestBlock }) {
+        this.handleRevealNotSubmittedOnTime(payload.block)
+        this.randomnessRepository.pruneRandomnesses(payload.block.timestamp).then((result) => {
+            if (result.isErr()) {
+                console.error("Failed to prune commitments", result.error)
+            }
+        })
+    }
+
     private async handleRevealNotSubmittedOnTime(block: LatestBlock) {
         const randomnesses = this.randomnessRepository.getRandomnessInStatus(RandomnessStatus.COMMITMENT_EXECUTED)
 
@@ -148,13 +158,6 @@ class RandomnessService {
             }
         })
 
-        // We don't await for pruning, because we don't want to block the transaction collection
-        this.randomnessRepository.pruneRandomnesses(block.timestamp).then((result) => {
-            if (result.isErr()) {
-                console.error("Failed to prune commitments", result.error)
-            }
-        })
-
         return transactions
     }
 }

packages/transaction-manager/lib/HookManager.ts

@@ -1,17 +1,28 @@
+import type { LatestBlock } from "./BlockMonitor"
 import { Topics, eventBus } from "./EventBus.js"
 import type { Transaction } from "./Transaction.js"
 
 export enum TxmHookType {
     All = "All",
     TransactionStatusChanged = "TransactionStatusChanged",
+    NewBlock = "NewBlock",
 }
 
-export type TxmHookPayload = {
-    type: TxmHookType
+export type TxmTransactionStatusChangedHookPayload = {
+    type: TxmHookType.TransactionStatusChanged
     transaction: Transaction
 }
 
-export type TxmHookHandler = (event: TxmHookPayload) => void
+export type TxmNewBlockHookPayload = {
+    type: TxmHookType.NewBlock
+    block: LatestBlock
+}
+
+export type TxmHookPayload = TxmTransactionStatusChangedHookPayload | TxmNewBlockHookPayload
+
+export type TxmHookHandler<T extends TxmHookType = TxmHookType> = (
+    event: Extract<TxmHookPayload, { type: T }> extends never ? TxmHookPayload : Extract<TxmHookPayload, { type: T }>,
+) => void
 
 /**
  * This module manages the hooks system. A hook in the transaction manager is a callback function that
@@ -24,31 +35,42 @@ export type TxmHookHandler = (event: TxmHookPayload) => void
  * - The callback function that executes when the event occurs.
  */
 export class HookManager {
-    private hooks: Record<TxmHookType, TxmHookHandler[]>
+    private hooks: {
+        [T in TxmHookType]: TxmHookHandler<T>[]
+    }
 
     constructor() {
         this.hooks = {
             [TxmHookType.All]: [],
             [TxmHookType.TransactionStatusChanged]: [],
+            [TxmHookType.NewBlock]: [],
         }
         eventBus.on(Topics.TransactionStatusChanged, this.onTransactionStatusChanged.bind(this))
+        eventBus.on(Topics.NewBlock, this.onNewBlock.bind(this))
     }
 
-    public async addHook(handler: TxmHookHandler, type: TxmHookType): Promise<void> {
+    public async addHook<T extends TxmHookType>(handler: TxmHookHandler<T>, type: T): Promise<void> {
         if (!this.hooks[type]) {
             this.hooks[type] = []
         }
         this.hooks[type].push(handler)
     }
 
-    private async onTransactionStatusChanged(payload: {
-        transaction: Transaction
-    }): Promise<void> {
-        this.hooks[TxmHookType.TransactionStatusChanged].concat(this.hooks[TxmHookType.All]).map((h) =>
+    private async onTransactionStatusChanged(payload: { transaction: Transaction }): Promise<void> {
+        ;[...this.hooks[TxmHookType.TransactionStatusChanged], ...this.hooks[TxmHookType.All]].forEach((h) =>
             h({
                 type: TxmHookType.TransactionStatusChanged,
                 transaction: payload.transaction,
             }),
         )
     }
+
+    private async onNewBlock(block: LatestBlock): Promise<void> {
+        ;[...this.hooks[TxmHookType.NewBlock], ...this.hooks[TxmHookType.All]].forEach((h) =>
+            h({
+                type: TxmHookType.NewBlock,
+                block,
+            }),
+        )
+    }
 }

packages/transaction-manager/lib/TransactionManager.ts

@@ -263,7 +263,7 @@ export class TransactionManager {
      * @param type - The type of hook to add.
      * @param handler - The handler function to add.
      */
-    public async addHook(handler: TxmHookHandler, type: TxmHookType): Promise<void> {
+    public async addHook<T extends TxmHookType>(handler: TxmHookHandler<T>, type: T): Promise<void> {
         await this.hookManager.addHook(handler, type)
     }