chore: use metadata inline instead of having a dedicated database (#510)

* chore: use metadata inline instead of having a dedicated database * fix: only store current_block when there is one * lint * chore: add current block during load * lint * fix: return next instead of evaluating it --------- Co-authored-by: Maycon Amaro <[email protected]>
cloudwalk · Apr 3, 2024 · b921c54 · b921c54
1 parent 5aa0203
commit b921c54
Show file tree

Hide file tree

Showing 5 changed files with 86 additions and 61 deletions.
diff --git a/.sqlx/query-3aa3f853d45b3fadcc9eb1a80cc45233482a14c82ac8a6630922bdcefae3cfd8.json b/.sqlx/query-3aa3f853d45b3fadcc9eb1a80cc45233482a14c82ac8a6630922bdcefae3cfd8.json
diff --git a/...8fab15194d30ff46de0488113858562eb5f5.json → ...f87eeff0cbc426765dd616f70a8015196aa3.json b/...8fab15194d30ff46de0488113858562eb5f5.json → ...f87eeff0cbc426765dd616f70a8015196aa3.json
diff --git a/.sqlx/query-fc28957dbf90502fd28723241c2f686e23c971a3b67391d63e5dadd690808e11.json b/.sqlx/query-fc28957dbf90502fd28723241c2f686e23c971a3b67391d63e5dadd690808e11.json
diff --git a/src/eth/storage/hybrid/hybrid_state.rs b/src/eth/storage/hybrid/hybrid_state.rs
@@ -92,21 +92,25 @@ impl HybridStorageState {
 
         // Spawn the first blocking task for accounts
         let accounts_task = tokio::spawn(async move {
+            let current_block_number = self_clone_accounts.get_current_block_number();
             let account_rows = sqlx::query_as!(
                 AccountRow,
                 "
-            SELECT DISTINCT ON (address)
-                address,
-                nonce,
-                balance,
-                bytecode,
-                code_hash
-            FROM
-                neo_accounts
-            ORDER BY
-                address,
-                block_number DESC
-            "
+                SELECT DISTINCT ON (address)
+                    address,
+                    nonce,
+                    balance,
+                    bytecode,
+                    code_hash
+                FROM
+                    neo_accounts
+                WHERE
+                    block_number > $1
+                ORDER BY
+                    address,
+                    block_number DESC
+                ",
+                current_block_number,
             )
             .fetch_all(&pool_clone_accounts)
             .await?;
@@ -131,20 +135,24 @@ impl HybridStorageState {
 
         // Spawn the second blocking task for slots
         let slots_task = tokio::spawn(async move {
+            let current_block_number = self_clone_slots.get_current_block_number();
             let slot_rows = sqlx::query_as!(
                 SlotRow,
                 "
-            SELECT DISTINCT ON (account_address, slot_index)
-                account_address,
-                slot_index,
-                value
-            FROM
-                neo_account_slots
-            ORDER BY
-                account_address,
-                slot_index,
-                block_number DESC
-            "
+                SELECT DISTINCT ON (account_address, slot_index)
+                    account_address,
+                    slot_index,
+                    value
+                FROM
+                    neo_account_slots
+                WHERE
+                    block_number > $1
+                ORDER BY
+                    account_address,
+                    slot_index,
+                    block_number DESC
+                ",
+                current_block_number,
             )
             .fetch_all(&pool_clone_slots)
             .await?;
@@ -162,9 +170,9 @@ impl HybridStorageState {
         // Check the results of both tasks
         for result in results {
             match result {
-                Ok(Ok(())) => continue,                      // Successfully completed task
-                Ok(Err(e)) => return Err(e),                 // Task completed with an error
-                Err(e) => return Err(anyhow::Error::new(e)), // Task panicked
+                Ok(Ok(())) => continue,
+                Ok(Err(e)) => return Err(e),
+                Err(e) => return Err(anyhow::Error::new(e)),
             }
         }
 

diff --git a/src/eth/storage/hybrid/rocks_db.rs b/src/eth/storage/hybrid/rocks_db.rs
@@ -69,6 +69,15 @@ impl<K: Serialize + for<'de> Deserialize<'de> + std::hash::Hash + Eq, V: Seriali
         bincode::deserialize(&value_bytes).ok()
     }
 
+    pub fn get_current_block_number(&self) -> i64 {
+        let Ok(serialized_key) = bincode::serialize(&"current_block") else {
+            return -1;
+        };
+        let Ok(Some(value_bytes)) = self.db.get(serialized_key) else { return -1 };
+
+        bincode::deserialize(&value_bytes).ok().unwrap_or(-1)
+    }
+
     // Mimics the 'insert' functionality of a HashMap
     pub fn insert(&self, key: K, value: V) {
         let serialized_key = bincode::serialize(&key).unwrap();
@@ -153,6 +162,10 @@ impl<'a, K: Serialize + for<'de> Deserialize<'de> + std::hash::Hash + Eq, V: Ser
             Some(key_value) => {
                 let (key, value) = key_value.unwrap(); // XXX deal with the result
 
+                if key == bincode::serialize(&"current_block").unwrap().into_boxed_slice() {
+                    return self.next();
+                }
+
                 let key: K = bincode::deserialize(&key).unwrap();
                 let value: V = bincode::deserialize(&value).unwrap();
                 Some((key, value))