chore(randomness): pr review

Author: GabrielMartinezRodriguez

apps/randomness-monitor/README.md

@@ -0,0 +1,9 @@
+# Randomness Monitor
+
+This application monitors the randomness service by directly inspecting the blockchain to verify whether randomness data is included in each block.
+
+The results are stored in a SQLite database and visualized via Grafana on the following dashboard:
+
+🔗 [View Dashboard](https://grafana.happy.tech/goto/BMpaDZbNg?orgId=1)
+
+In addition to visualization, the collected data is used to trigger alerts when the randomness service's performance drops below 95% block coverage.

apps/randomness-monitor/src/Monitoring.ts apps/randomness-monitor/src/Check.tsapps/randomness-monitor/src/Monitoring.ts renamed to apps/randomness-monitor/src/Check.ts

@@ -1,19 +1,19 @@
-export enum MonitoringResult {
+export enum CheckResult {
     Success = "success",
     Failure = "failure",
 }
 
-export class Monitoring {
+export class Check {
     readonly blockNumber: bigint
     readonly blockTimestamp: bigint
-    readonly result: MonitoringResult
+    readonly result: CheckResult
     readonly errorDescription: string | undefined
     readonly value: string | undefined
 
     constructor(
         blockNumber: bigint,
         blockTimestamp: bigint,
-        result: MonitoringResult,
+        result: CheckResult,
         errorDescription?: string,
         value?: string,
     ) {

apps/randomness-monitor/src/CheckRepository.ts

@@ -0,0 +1,38 @@
+import { unknownToError } from "@happy.tech/common"
+import { type Result, ResultAsync, err, ok } from "neverthrow"
+import { db } from "./db/driver"
+import { checkEntityToRow, checkRowToEntity } from "./db/types"
+import type { Check } from "./Check"
+
+const PRUNE_BLOCK_TIMESTAMP_THRESHOLD_SECONDS = 60 * 60 * 24 * 30 // 30 days
+
+export class CheckRepository {
+    async saveCheck(check: Check): Promise<Result<void, Error>> {
+        const row = checkEntityToRow(check)
+
+        return await ResultAsync.fromPromise(db.insertInto("checks").values(row).execute(), unknownToError).map(
+            () => undefined,
+        )
+    }
+
+    async findLatestCheck(): Promise<Result<Check | undefined, Error>> {
+        const result = await ResultAsync.fromPromise(
+            db.selectFrom("checks").selectAll().orderBy("blockNumber", "desc").limit(1).executeTakeFirst(),
+            unknownToError,
+        )
+        if (result.isErr()) {
+            return err(result.error)
+        }
+        return ok(result.value ? checkRowToEntity(result.value) : undefined)
+    }
+
+    async pruneChecks(blockTimestamp: bigint): Promise<Result<void, Error>> {
+        return await ResultAsync.fromPromise(
+            db
+                .deleteFrom("checks")
+                .where("blockTimestamp", "<", Number(blockTimestamp) - PRUNE_BLOCK_TIMESTAMP_THRESHOLD_SECONDS)
+                .execute(),
+            unknownToError,
+        ).map(() => undefined)
+    }
+}

apps/randomness-monitor/src/MonitorigRepository.ts

@@ -3,7 +3,7 @@ import type { Database } from "../types"
 
 export async function up(db: Kysely<Database>) {
     await db.schema
-        .createTable("monitoring")
+        .createTable("checks")
         .addColumn("blockNumber", "integer", (col) => col.notNull())
         .addColumn("blockTimestamp", "integer", (col) => col.notNull())
         .addColumn("result", "text", (col) => col.notNull())

apps/randomness-monitor/src/db/migrations/Migration20250403123000.ts

@@ -1,15 +1,15 @@
-import { Monitoring, type MonitoringResult } from "../Monitoring"
+import { Check, type CheckResult } from "../Check"
 
-export interface MonitoringRow {
+export interface CheckRow {
     blockNumber: number
     blockTimestamp: number
-    result: MonitoringResult
+    result: CheckResult
     errorDescription: string | undefined
     value: string | undefined
 }
 
-export function monitoringRowToEntity(row: MonitoringRow): Monitoring {
-    return new Monitoring(
+export function checkRowToEntity(row: CheckRow): Check {
+    return new Check(
         BigInt(row.blockNumber),
         BigInt(row.blockTimestamp),
         row.result,
@@ -18,7 +18,7 @@ export function monitoringRowToEntity(row: MonitoringRow): Monitoring {
     )
 }
 
-export function monitoringEntityToRow(entity: Monitoring): MonitoringRow {
+export function checkEntityToRow(entity: Check): CheckRow {
     return {
         blockNumber: Number(entity.blockNumber),
         blockTimestamp: Number(entity.blockTimestamp),
@@ -29,5 +29,5 @@ export function monitoringEntityToRow(entity: Monitoring): MonitoringRow {
 }
 
 export interface Database {
-    monitoring: MonitoringRow
+    checks: CheckRow
 }

apps/randomness-monitor/src/db/types.ts

@@ -1,17 +1,18 @@
 import { bigIntReplacer, unknownToError } from "@happy.tech/common"
+import { getUrlProtocol } from "@happy.tech/common"
 import { abis } from "@happy.tech/contracts/random/anvil"
 import { type Result, err, ok } from "neverthrow"
 import { http, type Block, type PublicClient, type Transport, createPublicClient, defineChain, webSocket } from "viem"
-import { MonitoringRepository } from "./MonitorigRepository"
-import { Monitoring, MonitoringResult } from "./Monitoring"
+import { CheckRepository } from "./CheckRepository"
+import { Check, CheckResult } from "./Check"
 import { env } from "./env"
-import { getUrlProtocol } from "./utils/getUrlProtocol"
+import { logger } from "./utils/logger"
 
 /**
  * Main monitoring service for tracking blockchain randomness
  */
 export class MonitoringService {
-    private readonly monitoringRepository: MonitoringRepository
+    private readonly checkRepository: CheckRepository
     private readonly viemClient: PublicClient
     private readonly protocol: "http" | "websocket"
 
@@ -20,7 +21,7 @@ export class MonitoringService {
     private isProcessing = false
 
     constructor() {
-        this.monitoringRepository = new MonitoringRepository()
+        this.checkRepository = new CheckRepository()
 
         const protocolResult = getUrlProtocol(env.RPC_URL)
 
@@ -90,14 +91,14 @@ export class MonitoringService {
      * Initialize monitoring state from database
      */
     private async initializeMonitoring(): Promise<void> {
-        const latestMonitoring = await this.monitoringRepository.findLatestMonitoring()
+        const latestCheck = await this.checkRepository.findLatestCheck()
 
-        if (latestMonitoring.isErr()) {
-            console.error("Failed to retrieve latest monitoring:", latestMonitoring.error)
+        if (latestCheck.isErr()) {
+            console.error("Failed to retrieve latest check:", latestCheck.error)
             process.exit(1)
         }
 
-        this.latestMonitoringBlockNumber = latestMonitoring.value?.blockNumber
+        this.latestMonitoringBlockNumber = latestCheck.value?.blockNumber
         console.log("Starting monitoring from block:", this.latestMonitoringBlockNumber)
     }
 
@@ -109,7 +110,7 @@ export class MonitoringService {
             return
         }
 
-        this.monitoringRepository.pruneMonitoring(block.timestamp)
+        this.checkRepository.pruneChecks(block.timestamp)
 
         this.latestBlockchainBlockNumber = block.number
 
@@ -135,19 +136,17 @@ export class MonitoringService {
                 this.latestMonitoringBlockNumber = this.latestBlockchainBlockNumber
             }
 
-            if (this.latestMonitoringBlockNumber && this.latestBlockchainBlockNumber) {
-                let blockToMonitor = this.latestMonitoringBlockNumber + 1n
-                const endBlock = this.latestBlockchainBlockNumber
+            let blockToMonitor = this.latestMonitoringBlockNumber + 1n
+            const endBlock = this.latestBlockchainBlockNumber
 
-                while (blockToMonitor < endBlock) {
-                    const result = await this.monitorBlock(blockToMonitor)
-                    if (result.isErr()) {
-                        break
-                    }
-
-                    this.latestMonitoringBlockNumber = blockToMonitor
-                    blockToMonitor = blockToMonitor + 1n
+            while (blockToMonitor < endBlock) {
+                const result = await this.monitorBlock(blockToMonitor)
+                if (result.isErr()) {
+                    break
                 }
+
+                this.latestMonitoringBlockNumber = blockToMonitor
+                blockToMonitor = blockToMonitor + 1n
             }
         } catch (error) {
             console.error("Error in processing monitoring:", error)
@@ -160,7 +159,7 @@ export class MonitoringService {
      * Monitor a specific block for randomness
      */
     private async monitorBlock(blockNumber: bigint): Promise<Result<void, Error>> {
-        console.log("Monitoring block", blockNumber)
+        logger.info(`Monitoring block ${blockNumber}`)
 
         let block: Block<bigint, false, "latest"> | undefined
         try {
@@ -184,12 +183,12 @@ export class MonitoringService {
                 functionName: "random",
                 blockNumber,
             })
-            await this.monitoringRepository
-                .saveMonitoring(
-                    new Monitoring(blockNumber, block.timestamp, MonitoringResult.Success, undefined, random),
+            await this.checkRepository
+                .saveCheck(
+                    new Check(blockNumber, block.timestamp, CheckResult.Success, undefined, random),
                 )
                 .catch((error) => {
-                    console.error("Error in saving monitoring:", error)
+                    console.error("Error in saving check:", error)
                 })
         } catch (err: unknown) {
             let errorMessage: string | undefined
@@ -200,10 +199,10 @@ export class MonitoringService {
                 errorMessage = JSON.stringify(err, bigIntReplacer)
             }
 
-            await this.monitoringRepository
-                .saveMonitoring(new Monitoring(blockNumber, block.timestamp, MonitoringResult.Failure, errorMessage))
+            await this.checkRepository
+                .saveCheck(new Check(blockNumber, block.timestamp, CheckResult.Failure, errorMessage))
                 .catch((error) => {
-                    console.error("Error in saving monitoring:", error)
+                    console.error("Error in saving check:", error)
                 })
         }
 

apps/randomness-monitor/src/index.ts

@@ -0,0 +1,2 @@
+import { Logger } from "@happy.tech/common"
+export const logger = Logger.create("RandomnessMonitor")