chore(randomness): pr review

Author: GabrielMartinezRodriguez

apps/randomness/src/Drand.ts

@@ -13,6 +13,13 @@ export class Drand {
     #status: DrandStatus
     #transactionIntentId: UUID | undefined
 
+    static readonly validTransitions: Record<DrandStatus, DrandStatus[]> = {
+        PENDING: [DrandStatus.SUBMITTED, DrandStatus.FAILED],
+        SUBMITTED: [DrandStatus.SUCCESS, DrandStatus.FAILED],
+        SUCCESS: [],
+        FAILED: [],
+    }
+
     constructor(params: {
         status: DrandStatus
         transactionIntentId?: UUID
@@ -26,49 +33,42 @@ export class Drand {
     }
 
     private setStatus(newStatus: DrandStatus): void {
-        const validTransitions: Record<DrandStatus, DrandStatus[]> = {
-            PENDING: [DrandStatus.SUBMITTED, DrandStatus.FAILED],
-            SUBMITTED: [DrandStatus.SUCCESS, DrandStatus.FAILED],
-            SUCCESS: [],
-            FAILED: [],
-        }
-
-        if (!validTransitions[this.#status].includes(newStatus)) {
+        if (!Drand.validTransitions[this.#status].includes(newStatus)) {
             throw new Error(`Invalid status transition from ${this.#status} to ${newStatus}`)
         }
 
         this.#status = newStatus
     }
 
-    public executionSuccess(): void {
+    executionSuccess(): void {
         this.setStatus(DrandStatus.SUCCESS)
     }
 
-    public transactionSubmitted(): void {
+    transactionSubmitted(): void {
         this.setStatus(DrandStatus.SUBMITTED)
     }
 
-    public transactionFailed(): void {
+    transactionFailed(): void {
         this.setStatus(DrandStatus.FAILED)
     }
 
-    public get round(): bigint {
+    get round(): bigint {
         return this.#round
     }
 
-    public get signature(): Hex | undefined {
+    get signature(): Hex | undefined {
         return this.#signature
     }
 
-    public get status(): DrandStatus {
+    get status(): DrandStatus {
         return this.#status
     }
 
-    public get transactionIntentId(): UUID | undefined {
+    get transactionIntentId(): UUID | undefined {
         return this.#transactionIntentId
     }
 
-    static createDrand(params: {
+    static create(params: {
         transactionIntentId?: UUID
         round: bigint
         signature: Hex

apps/randomness/src/DrandRepository.ts

@@ -1,12 +1,10 @@
 import { type Hex, type UUID, bigIntToZeroPadded, unknownToError } from "@happy.tech/common"
 import { type Result, ResultAsync } from "neverthrow"
-import { Drand, DrandStatus } from "./Drand"
+import { Drand } from "./Drand"
+import { DIGITS_MAX_UINT256 } from "./constants"
 import { db } from "./db/driver"
 import type { DrandRow } from "./db/types"
 
-// Quantity of digits in the max uint256 value
-export const DIGITS_MAX_UINT256 = 78
-
 export class DrandRepository {
     private cache: Drand[] = []
 
@@ -28,13 +26,13 @@ export class DrandRepository {
         }
     }
 
-    public async start(): Promise<void> {
+    async start(): Promise<void> {
         const drandsDb = (await db.selectFrom("drands").selectAll().execute()).map(this.rowToEntity)
 
         this.cache.push(...drandsDb)
     }
 
-    public async saveDrand(drand: Drand): Promise<Result<void, Error>> {
+    async saveDrand(drand: Drand): Promise<Result<void, Error>> {
         const row = this.entityToRow(drand)
 
         const result = await ResultAsync.fromPromise(db.insertInto("drands").values(row).execute(), unknownToError)
@@ -46,14 +44,14 @@ export class DrandRepository {
         return result.map(() => undefined)
     }
 
-    public getOldestDrandRound(): bigint | undefined {
+    getOldestDrandRound(): bigint | undefined {
         if (this.cache.length === 0) {
             return undefined
         }
         return this.cache.reduce((acc, drand) => (drand.round < acc ? drand.round : acc), this.cache[0].round)
     }
 
-    public findRoundGapsInRange(startRound: bigint, endRound: bigint): bigint[] {
+    findRoundGapsInRange(startRound: bigint, endRound: bigint): bigint[] {
         const roundGaps = []
         for (let round = startRound; round <= endRound; round++) {
             if (!this.cache.find((drand) => drand.round === round)) {
@@ -63,19 +61,15 @@ export class DrandRepository {
         return roundGaps
     }
 
-    public getDrand(round: bigint): Drand | undefined {
+    getDrand(round: bigint): Drand | undefined {
         return this.cache.find((drand) => drand.round === round)
     }
 
-    public getDrandByTransactionIntentId(transactionIntentId: UUID): Drand | undefined {
+    getDrandByTransactionIntentId(transactionIntentId: UUID): Drand | undefined {
         return this.cache.find((drand) => drand.transactionIntentId === transactionIntentId)
     }
 
-    public getPendingDrands(): Drand[] {
-        return this.cache.filter((drand) => drand.status === DrandStatus.PENDING)
-    }
-
-    public async updateDrand(drand: Drand): Promise<Result<void, Error>> {
+    async updateDrand(drand: Drand): Promise<Result<void, Error>> {
         const row = this.entityToRow(drand)
         return ResultAsync.fromPromise(
             db

apps/randomness/src/DrandService.ts

@@ -4,7 +4,7 @@ import type { Hex } from "viem"
 import { z } from "zod"
 import { env } from "./env"
 
-export const drandBeaconSchema = z.object({
+const drandBeaconSchema = z.object({
     round: z.number().int().positive(),
     signature: z
         .string()
@@ -32,7 +32,7 @@ export enum DrandError {
 }
 
 export class DrandService {
-    public async getDrandBeacon(round: bigint): Promise<Result<DrandBeacon, DrandError>> {
+    async getDrandBeacon(round: bigint): Promise<Result<DrandBeacon, DrandError>> {
         if (round <= 0n) {
             return err(DrandError.InvalidRound)
         }
@@ -55,19 +55,16 @@ export class DrandService {
 
         const dataRaw = await response.value.json()
 
-        console.log(dataRaw)
         const parsed = drandBeaconSchema.safeParse(dataRaw)
 
         if (!parsed.success) {
             return err(DrandError.InvalidResponse)
         }
 
-        const data = parsed.data
-
-        return ok(data)
+        return ok(parsed.data)
     }
 
-    public currentRound(): bigint {
+    currentRound(): bigint {
         const currentTimestamp = nowInSeconds()
         const currentRound = Math.floor(
             (currentTimestamp - Number(env.EVM_DRAND_GENESIS_TIMESTAMP_SECONDS)) /

apps/randomness/src/Randomness.ts

@@ -13,12 +13,6 @@ export enum RandomnessStatus {
     REVEAL_NOT_SUBMITTED_ON_TIME = "REVEAL_NOT_SUBMITTED_ON_TIME",
 }
 
-export const FINALIZED_STATUSES = [
-    RandomnessStatus.REVEAL_EXECUTED,
-    RandomnessStatus.REVEAL_FAILED,
-    RandomnessStatus.REVEAL_NOT_SUBMITTED_ON_TIME,
-]
-
 export class Randomness {
     public blockNumber: bigint
     public value: bigint
@@ -43,33 +37,33 @@ export class Randomness {
         this.status = params.status
     }
 
-    public commitmentExecuted(): void {
+    commitmentExecuted(): void {
         this.status = RandomnessStatus.COMMITMENT_EXECUTED
     }
 
-    public revealExecuted(): void {
+    revealExecuted(): void {
         this.status = RandomnessStatus.REVEAL_EXECUTED
     }
 
-    public addCommitmentTransactionIntentId(intentId: UUID): void {
+    addCommitmentTransactionIntentId(intentId: UUID): void {
         this.commitmentTransactionIntentId = intentId
         this.status = RandomnessStatus.COMMITMENT_SUBMITTED
     }
 
-    public addRevealTransactionIntentId(intentId: UUID): void {
+    addRevealTransactionIntentId(intentId: UUID): void {
         this.revealTransactionIntentId = intentId
         this.status = RandomnessStatus.REVEAL_SUBMITTED
     }
 
-    public commitmentFailed(): void {
+    commitmentFailed(): void {
         this.status = RandomnessStatus.COMMITMENT_FAILED
     }
 
-    public revealFailed(): void {
+    revealFailed(): void {
         this.status = RandomnessStatus.REVEAL_FAILED
     }
 
-    public revealNotSubmittedOnTime(): void {
+    revealNotSubmittedOnTime(): void {
         this.status = RandomnessStatus.REVEAL_NOT_SUBMITTED_ON_TIME
     }
 

apps/randomness/src/RandomnessRepository.ts

@@ -1,53 +1,52 @@
 import { type UUID, unknownToError } from "@happy.tech/common"
 import { bigIntToZeroPadded } from "@happy.tech/common"
 import { type Result, ResultAsync } from "neverthrow"
-import { FINALIZED_STATUSES, type Randomness, type RandomnessStatus } from "./Randomness"
+import { type Randomness, RandomnessStatus } from "./Randomness"
+import { DIGITS_MAX_UINT256 } from "./constants"
 import { db } from "./db/driver"
 import { randomnessEntityToRow, randomnessRowToEntity } from "./db/types"
 
-const COMMITMENT_PRUNE_INTERVAL_BLOCKS = 120n // 2 minutes
+const COMMITMENT_PRUNE_INTERVAL_BLOCKS = 60n // 2 minutes
 
-// Quantity of digits in the max uint256 value
-export const DIGITS_MAX_UINT256 = 78
+export const FINALIZED_STATUSES = [
+    RandomnessStatus.REVEAL_EXECUTED,
+    RandomnessStatus.REVEAL_FAILED,
+    RandomnessStatus.REVEAL_NOT_SUBMITTED_ON_TIME,
+]
 
 export class RandomnessRepository {
-    private readonly map = new Map<bigint, Randomness>()
+    // In-memory cache that maps block numbers to their corresponding Randomness
+    private readonly cache = new Map<bigint, Randomness>()
 
     async start(): Promise<void> {
         const randomnessesDb = (await db.selectFrom("randomnesses").selectAll().execute()).map(randomnessRowToEntity)
         for (const randomness of randomnessesDb) {
-            this.map.set(randomness.blockNumber, randomness)
+            this.cache.set(randomness.blockNumber, randomness)
         }
     }
 
     getRandomnessForBlockNumber(blockNumber: bigint): Randomness | undefined {
-        return this.map.get(blockNumber)
+        return this.cache.get(blockNumber)
     }
 
     getRandomnessForIntentId(intentId: UUID): Randomness | undefined {
-        return Array.from(this.map.values()).find(
+        return Array.from(this.cache.values()).find(
             (randomness) =>
                 randomness.commitmentTransactionIntentId === intentId ||
                 randomness.revealTransactionIntentId === intentId,
         )
     }
 
-    getRandomnessInBlockRange(start: bigint, end: bigint): Randomness[] {
-        return Array.from(this.map.values()).filter(
-            (randomness) => randomness.blockNumber >= start && randomness.blockNumber <= end,
-        )
-    }
-
     getRandomnessInStatus(status: RandomnessStatus): Randomness[] {
-        return Array.from(this.map.values()).filter((randomness) => randomness.status === status)
+        return Array.from(this.cache.values()).filter((randomness) => randomness.status === status)
     }
 
     /**
      * Save a randomness to the database
      * Even if the operation fails, the randomness will be saved in a in-memory cache
      */
     async saveRandomness(randomness: Randomness): Promise<Result<void, Error>> {
-        this.map.set(randomness.blockNumber, randomness)
+        this.cache.set(randomness.blockNumber, randomness)
         const row = randomnessEntityToRow(randomness)
         return await ResultAsync.fromPromise(db.insertInto("randomnesses").values(row).execute(), unknownToError).map(
             () => undefined,
@@ -59,7 +58,7 @@ export class RandomnessRepository {
      * Even if the operation fails, the randomness will be updated in a in-memory cache
      */
     async updateRandomness(randomness: Randomness): Promise<Result<void, Error>> {
-        this.map.set(randomness.blockNumber, randomness)
+        this.cache.set(randomness.blockNumber, randomness)
         const row = randomnessEntityToRow(randomness)
         return await ResultAsync.fromPromise(
             db
@@ -73,9 +72,9 @@ export class RandomnessRepository {
 
     async pruneRandomnesses(latestBlock: bigint): Promise<Result<void, Error>> {
         const cutoffBlock = latestBlock - COMMITMENT_PRUNE_INTERVAL_BLOCKS
-        for (const blockNumber of this.map.keys()) {
+        for (const blockNumber of this.cache.keys()) {
             if (blockNumber < cutoffBlock) {
-                this.map.delete(blockNumber)
+                this.cache.delete(blockNumber)
             }
         }
 

apps/randomness/src/TransactionFactory.ts

@@ -13,6 +13,11 @@ export class TransactionFactory {
     ) {}
 
     createCommitmentTransaction(randomness: Randomness): Transaction {
+        // The commitment transaction must be submitted at least one block
+        // before the deadline, because submissions after the precommit delay
+        // are not allowed. We compute the deadline by subtracting the precommit
+        // delay from the block number, multiplying by the block time, and adding
+        // the genesis timestamp.
         const deadline = Number(
             (randomness.blockNumber - this.precommitDelay) * env.BLOCK_TIME + env.HAPPY_GENESIS_TIMESTAMP_SECONDS,
         )
@@ -26,6 +31,9 @@ export class TransactionFactory {
     }
 
     createRevealValueTransaction(randomness: Randomness): Transaction {
+        // The reveal transaction must execute in its target block.
+        // We calculate its deadline by multiplying the block number by the block time
+        // and adding the genesis timestamp.
         const deadline = Number(randomness.blockNumber * env.BLOCK_TIME + env.HAPPY_GENESIS_TIMESTAMP_SECONDS)
 
         return this.transactionManager.createTransaction({
@@ -37,7 +45,7 @@ export class TransactionFactory {
         })
     }
 
-    public createPostDrandTransaction({
+    createPostDrandTransaction({
         round,
         signature,
     }: {

apps/randomness/src/constants.ts

@@ -0,0 +1,2 @@
+// Quantity of digits in the max uint256 value
+export const DIGITS_MAX_UINT256 = 78

apps/randomness/src/db/types.ts

@@ -1,7 +1,7 @@
 import { type Hex, type UUID, bigIntToZeroPadded } from "@happy.tech/common"
 import type { DrandStatus } from "../Drand"
 import { Randomness, type RandomnessStatus } from "../Randomness"
-import { DIGITS_MAX_UINT256 } from "../RandomnessRepository"
+import { DIGITS_MAX_UINT256 } from "../constants"
 
 // Values are stored as strings because they can be large numbers bigger than the max value of an SQLite integer
 export interface RandomnessRow {