refactor(db): some changes, add InMemoryDb

src/db/memory.rs

@@ -0,0 +1,61 @@
+use std::sync::{Arc, RwLock};
+
+use alloy::primitives::Address;
+use tracing::info;
+
+use super::{BlsPublicKey, DbResult, Operator, Registration, RegistryDb};
+
+#[derive(Debug, Clone)]
+pub(crate) struct InMemoryDb {
+    validator_registrations: Arc<RwLock<Vec<Registration>>>,
+    operator_registrations: Arc<RwLock<Vec<Operator>>>,
+}
+
+#[async_trait::async_trait]
+impl RegistryDb for InMemoryDb {
+    async fn register_validators(&self, registration: Registration) -> DbResult<()> {
+        info!(
+            keys_count = registration.validator_pubkeys.len(),
+            sig_count = registration.signatures.len(),
+            digest = ?registration.digest(),
+            "NoOpDb: register_validators"
+        );
+
+        let mut registrations = self.validator_registrations.write().unwrap();
+        registrations.push(registration);
+
+        Ok(())
+    }
+
+    async fn register_operator(&self, operator: Operator) -> DbResult<()> {
+        info!(signer = %operator.signer, "NoOpDb: register_operator");
+
+        let mut operators = self.operator_registrations.write().unwrap();
+        operators.push(operator);
+
+        Ok(())
+    }
+
+    async fn get_operator(&self, signer: Address) -> DbResult<Option<Operator>> {
+        let operators = self.operator_registrations.read().unwrap();
+        let operator = operators.iter().find(|op| op.signer == signer);
+
+        match operator {
+            Some(op) => Ok(Some(op.clone())),
+            None => Ok(None),
+        }
+    }
+
+    async fn get_validator_registration(
+        &self,
+        pubkey: BlsPublicKey,
+    ) -> DbResult<Option<Registration>> {
+        let registrations = self.validator_registrations.read().unwrap();
+        let registration = registrations.iter().find(|reg| reg.validator_pubkeys.contains(&pubkey));
+
+        match registration {
+            Some(reg) => Ok(Some(reg.clone())),
+            None => Ok(None),
+        }
+    }
+}

src/db/mod.rs

@@ -12,8 +12,8 @@ use crate::primitives::{
 mod types;
 
 /// No-op database implementation.
-mod noop;
-pub(crate) use noop::NoOpDb;
+mod memory;
+pub(crate) use memory::InMemoryDb;
 
 /// SQL database backend implementation.
 mod sql;
@@ -50,8 +50,11 @@ pub(crate) trait RegistryDb: Clone {
     async fn register_operator(&self, operator: Operator) -> DbResult<()>;
 
     /// Get an operator from the database.
-    async fn get_operator(&self, signer: Address) -> DbResult<Operator>;
+    async fn get_operator(&self, signer: Address) -> DbResult<Option<Operator>>;
 
     /// Get a validator registration from the database.
-    async fn get_validator_registration(&self, pubkey: BlsPublicKey) -> DbResult<Registration>;
+    async fn get_validator_registration(
+        &self,
+        pubkey: BlsPublicKey,
+    ) -> DbResult<Option<Registration>>;
 }

src/db/sql.rs

@@ -97,33 +97,44 @@ impl RegistryDb for SQLDb<Postgres> {
         Ok(())
     }
 
-    async fn get_operator(&self, signer: Address) -> DbResult<Operator> {
-        let row: OperatorRow = sqlx::query_as(
+    async fn get_operator(&self, signer: Address) -> DbResult<Option<Operator>> {
+        let row: Option<OperatorRow> = sqlx::query_as(
             "
             SELECT signer, rpc, protocol, source, collateral_tokens, collateral_amounts, last_update
             FROM operators
             WHERE signer = $1
             ",
         )
         .bind(signer.to_vec())
-        .fetch_one(&self.conn)
+        .fetch_optional(&self.conn)
         .await?;
 
-        row.try_into()
+        let Some(row) = row else {
+            return Ok(None);
+        };
+
+        Ok(Some(row.try_into()?))
     }
 
-    async fn get_validator_registration(&self, pubkey: BlsPublicKey) -> DbResult<Registration> {
-        let row: ValidatorRegistrationRow = sqlx::query_as(
+    async fn get_validator_registration(
+        &self,
+        pubkey: BlsPublicKey,
+    ) -> DbResult<Option<Registration>> {
+        let row: Option<ValidatorRegistrationRow> = sqlx::query_as(
             "
             SELECT pubkey, signature, expiry, gas_limit, operator, priority, source, last_update
             FROM validator_registrations
             WHERE pubkey = $1
             ",
         )
         .bind(pubkey.serialize().to_vec())
-        .fetch_one(&self.conn)
+        .fetch_optional(&self.conn)
         .await?;
 
-        row.try_into()
+        let Some(row) = row else {
+            return Ok(None);
+        };
+
+        Ok(Some(row.try_into()?))
     }
 }