chore(randomness): pr review

Author: GabrielMartinezRodriguez

packages/randomness-service/src/RandomnessRepository.ts

@@ -1,9 +1,9 @@
 import { type UUID, unknownToError } from "@happychain/common"
 import { bigIntToZeroPadded } from "@happychain/common"
 import { type Result, ResultAsync } from "neverthrow"
-import { Randomness, type RandomnessStatus } from "./Randomness"
+import type { Randomness, RandomnessStatus } from "./Randomness"
 import { db } from "./db/driver"
-import type { RandomnessRow } from "./db/types"
+import { randomnessEntityToRow, randomnessRowToEntity } from "./db/types"
 
 const COMMITMENT_PRUNE_INTERVAL_SECONDS = 120n // 2 minutes
 
@@ -13,30 +13,8 @@ export const DIGITS_MAX_UINT256 = 78
 export class RandomnessRepository {
     private readonly map = new Map<bigint, Randomness>()
 
-    private rowToEntity(row: RandomnessRow): Randomness {
-        return new Randomness({
-            timestamp: BigInt(row.timestamp),
-            value: BigInt(row.value),
-            hashedValue: row.hashedValue,
-            commitmentTransactionIntentId: row.commitmentTransactionIntentId,
-            revealTransactionIntentId: row.revealTransactionIntentId,
-            status: row.status,
-        })
-    }
-
-    private entityToRow(entity: Randomness): RandomnessRow {
-        return {
-            timestamp: bigIntToZeroPadded(entity.timestamp, DIGITS_MAX_UINT256),
-            value: bigIntToZeroPadded(entity.value, DIGITS_MAX_UINT256),
-            hashedValue: entity.hashedValue,
-            commitmentTransactionIntentId: entity.commitmentTransactionIntentId,
-            revealTransactionIntentId: entity.revealTransactionIntentId,
-            status: entity.status,
-        }
-    }
-
     async start(): Promise<void> {
-        const randomnessesDb = (await db.selectFrom("randomnesses").selectAll().execute()).map(this.rowToEntity)
+        const randomnessesDb = (await db.selectFrom("randomnesses").selectAll().execute()).map(randomnessRowToEntity)
         for (const randomness of randomnessesDb) {
             this.map.set(randomness.timestamp, randomness)
         }
@@ -70,7 +48,7 @@ export class RandomnessRepository {
      */
     async saveRandomness(randomness: Randomness): Promise<Result<void, Error>> {
         this.map.set(randomness.timestamp, randomness)
-        const row = this.entityToRow(randomness)
+        const row = randomnessEntityToRow(randomness)
         return await ResultAsync.fromPromise(db.insertInto("randomnesses").values(row).execute(), unknownToError).map(
             () => undefined,
         )
@@ -82,7 +60,7 @@ export class RandomnessRepository {
      */
     async updateRandomness(randomness: Randomness): Promise<Result<void, Error>> {
         this.map.set(randomness.timestamp, randomness)
-        const row = this.entityToRow(randomness)
+        const row = randomnessEntityToRow(randomness)
         return await ResultAsync.fromPromise(
             db
                 .updateTable("randomnesses")

…ness-service/src/TransactionFactories.ts …omness-service/src/TransactionFactory.tspackages/randomness-service/src/TransactionFactories.ts renamed to packages/randomness-service/src/TransactionFactory.ts packages/randomness-service/src/TransactionFactories.ts renamed to packages/randomness-service/src/TransactionFactory.ts

@@ -2,7 +2,7 @@ import type { Transaction, TransactionManager } from "@happychain/transaction-ma
 import type { Address } from "viem"
 import type { Randomness } from "./Randomness"
 
-export class TransactionFactories {
+export class TransactionFactory {
     private readonly transactionManager: TransactionManager
     private readonly randomContractAddress: Address
     private readonly precommitDelay: bigint

packages/randomness-service/src/db/types.ts

@@ -1,5 +1,6 @@
-import type { Hex, UUID } from "@happychain/common"
-import type { RandomnessStatus } from "../Randomness"
+import { type Hex, type UUID, bigIntToZeroPadded } from "@happychain/common"
+import { Randomness, type RandomnessStatus } from "../Randomness"
+import { DIGITS_MAX_UINT256 } from "../RandomnessRepository"
 
 // Values are stored as strings because they can be large numbers bigger than the max value of an SQLite integer
 export interface RandomnessRow {
@@ -14,3 +15,25 @@ export interface RandomnessRow {
 export interface Database {
     randomnesses: RandomnessRow
 }
+
+export function randomnessRowToEntity(row: RandomnessRow): Randomness {
+    return new Randomness({
+        timestamp: BigInt(row.timestamp),
+        value: BigInt(row.value),
+        hashedValue: row.hashedValue,
+        commitmentTransactionIntentId: row.commitmentTransactionIntentId,
+        revealTransactionIntentId: row.revealTransactionIntentId,
+        status: row.status,
+    })
+}
+
+export function randomnessEntityToRow(entity: Randomness): RandomnessRow {
+    return {
+        timestamp: bigIntToZeroPadded(entity.timestamp, DIGITS_MAX_UINT256),
+        value: bigIntToZeroPadded(entity.value, DIGITS_MAX_UINT256),
+        hashedValue: entity.hashedValue,
+        commitmentTransactionIntentId: entity.commitmentTransactionIntentId,
+        revealTransactionIntentId: entity.revealTransactionIntentId,
+        status: entity.status,
+    }
+}

packages/randomness-service/src/index.ts

@@ -4,13 +4,13 @@ import { abis } from "./ABI/random.js"
 import { CustomGasEstimator } from "./CustomGasEstimator.js"
 import { Randomness, RandomnessStatus } from "./Randomness.js"
 import { RandomnessRepository } from "./RandomnessRepository.js"
-import { TransactionFactories } from "./TransactionFactories.js"
+import { TransactionFactory } from "./TransactionFactory.js"
 import { env } from "./env.js"
 
 class RandomnessService {
     private readonly randomnessRepository: RandomnessRepository
     private readonly txm: TransactionManager
-    private readonly transactionFactories: TransactionFactories
+    private readonly transactionFactory: TransactionFactory
     constructor() {
         this.randomnessRepository = new RandomnessRepository()
         this.txm = new TransactionManager({
@@ -22,7 +22,7 @@ class RandomnessService {
                 url: env.RPC_URL,
             },
         })
-        this.transactionFactories = new TransactionFactories(this.txm, env.RANDOM_CONTRACT_ADDRESS, env.PRECOMMIT_DELAY)
+        this.transactionFactory = new TransactionFactory(this.txm, env.RANDOM_CONTRACT_ADDRESS, env.PRECOMMIT_DELAY)
 
         this.txm.addTransactionOriginator(this.onCollectTransactions.bind(this))
     }
@@ -109,7 +109,7 @@ class RandomnessService {
 
             const newRandomness = Randomness.createRandomness(timestamp)
 
-            const commitmentTransaction = this.transactionFactories.createCommitmentTransaction(newRandomness)
+            const commitmentTransaction = this.transactionFactory.createCommitmentTransaction(newRandomness)
 
             transactions.push(commitmentTransaction)
 
@@ -130,7 +130,7 @@ class RandomnessService {
             return transactions
         }
 
-        const revealValueTransaction = this.transactionFactories.createRevealValueTransaction(randomnessToReveal)
+        const revealValueTransaction = this.transactionFactory.createRevealValueTransaction(randomnessToReveal)
 
         transactions.unshift(revealValueTransaction)