Ocean API: rocks db implementation for ocean API

lib/Cargo.toml

@@ -79,7 +79,6 @@ jsonrpsee-server = "0.16"
 jsonrpsee-types = "0.16"
 
 axum = { version = "0.7.1", features = ["macros"] }
-
 tempdir = "0.3"
 
 rocksdb = { version = "0.21", default-features = false }

lib/Makefile.am

@@ -71,10 +71,6 @@ check:
 test:
 	$(CARGO) test $(CARGO_MANIFEST_ARG) $(CARGO_EXTRA_ARGS)
 
-.PHONY: clippy
-clippy:
-	$(CARGO) clippy $(CARGO_MANIFEST_ARG) $(CARGO_EXTRA_ARGS) -- -Dwarnings
-
 .PHONY: doc
 doc:
 	$(CARGO) doc $(CARGO_MANIFEST_ARG)

lib/ain-evm/src/storage/cache.rs

@@ -3,35 +3,30 @@ use std::{borrow::ToOwned, num::NonZeroUsize, sync::RwLock};
 use ethereum::{BlockAny, TransactionV2};
 use ethereum_types::{H256, U256};
 use lru::LruCache;
-use parking_lot::Mutex;
 
 use super::traits::{BlockStorage, Rollback, TransactionStorage};
 use crate::Result;
 
 #[derive(Debug)]
 pub struct Cache {
-    transactions: Mutex<LruCache<H256, TransactionV2>>,
-    blocks: Mutex<LruCache<U256, BlockAny>>,
-    block_hashes: Mutex<LruCache<H256, U256>>,
+    transactions: RwLock<LruCache<H256, TransactionV2>>,
+    blocks: RwLock<LruCache<U256, BlockAny>>,
+    block_hashes: RwLock<LruCache<H256, U256>>,
     latest_block: RwLock<Option<BlockAny>>,
-    contract_code: Mutex<LruCache<H256, Vec<u8>>>,
 }
 
 impl Cache {
     const DEFAULT_CACHE_SIZE: usize = 1000;
 
     pub fn new(cache_size: Option<usize>) -> Self {
         Cache {
-            transactions: Mutex::new(LruCache::new(
+            transactions: RwLock::new(LruCache::new(
                 NonZeroUsize::new(cache_size.unwrap_or(Self::DEFAULT_CACHE_SIZE)).unwrap(),
             )),
-            blocks: Mutex::new(LruCache::new(
+            blocks: RwLock::new(LruCache::new(
                 NonZeroUsize::new(cache_size.unwrap_or(Self::DEFAULT_CACHE_SIZE)).unwrap(),
             )),
-            block_hashes: Mutex::new(LruCache::new(
-                NonZeroUsize::new(cache_size.unwrap_or(Self::DEFAULT_CACHE_SIZE)).unwrap(),
-            )),
-            contract_code: Mutex::new(LruCache::new(
+            block_hashes: RwLock::new(LruCache::new(
                 NonZeroUsize::new(cache_size.unwrap_or(Self::DEFAULT_CACHE_SIZE)).unwrap(),
             )),
             latest_block: RwLock::new(None),
@@ -41,13 +36,19 @@ impl Cache {
 
 impl BlockStorage for Cache {
     fn get_block_by_number(&self, number: &U256) -> Result<Option<BlockAny>> {
-        let block = self.blocks.lock().get(number).map(ToOwned::to_owned);
+        let block = self
+            .blocks
+            .write()
+            .unwrap()
+            .get(number)
+            .map(ToOwned::to_owned);
         Ok(block)
     }
 
     fn get_block_by_hash(&self, block_hash: &H256) -> Result<Option<BlockAny>> {
         self.block_hashes
-            .lock()
+            .write()
+            .unwrap()
             .get(block_hash)
             .map_or(Ok(None), |block_number| {
                 self.get_block_by_number(block_number)
@@ -59,8 +60,11 @@ impl BlockStorage for Cache {
 
         let block_number = block.header.number;
         let hash = block.header.hash();
-        self.blocks.lock().put(block_number, block.clone());
-        self.block_hashes.lock().put(hash, block_number);
+        self.blocks
+            .write()
+            .unwrap()
+            .put(block_number, block.clone());
+        self.block_hashes.write().unwrap().put(hash, block_number);
         Ok(())
     }
 
@@ -83,7 +87,7 @@ impl BlockStorage for Cache {
 
 impl TransactionStorage for Cache {
     fn extend_transactions_from_block(&self, block: &BlockAny) -> Result<()> {
-        let mut cache = self.transactions.lock();
+        let mut cache = self.transactions.write().unwrap();
 
         for transaction in &block.transactions {
             let hash = transaction.hash();
@@ -93,7 +97,12 @@ impl TransactionStorage for Cache {
     }
 
     fn get_transaction_by_hash(&self, hash: &H256) -> Result<Option<TransactionV2>> {
-        let transaction = self.transactions.lock().get(hash).map(ToOwned::to_owned);
+        let transaction = self
+            .transactions
+            .write()
+            .unwrap()
+            .get(hash)
+            .map(ToOwned::to_owned);
         Ok(transaction)
     }
 
@@ -103,7 +112,8 @@ impl TransactionStorage for Cache {
         index: usize,
     ) -> Result<Option<TransactionV2>> {
         self.block_hashes
-            .lock()
+            .write()
+            .unwrap()
             .get(block_hash)
             .map_or(Ok(None), |block_number| {
                 self.get_transaction_by_block_number_and_index(block_number, index)
@@ -117,15 +127,17 @@ impl TransactionStorage for Cache {
     ) -> Result<Option<TransactionV2>> {
         let transaction = self
             .blocks
-            .lock()
+            .write()
+            .unwrap()
             .get(block_number)
             .and_then(|block| block.transactions.get(index).map(ToOwned::to_owned));
         Ok(transaction)
     }
 
     fn put_transaction(&self, transaction: &TransactionV2) -> Result<()> {
         self.transactions
-            .lock()
+            .write()
+            .unwrap()
             .put(transaction.hash(), transaction.clone());
         Ok(())
     }
@@ -134,28 +146,17 @@ impl TransactionStorage for Cache {
 impl Rollback for Cache {
     fn disconnect_latest_block(&self) -> Result<()> {
         if let Some(block) = self.get_latest_block()? {
-            let mut transaction_cache = self.transactions.lock();
+            let mut transaction_cache = self.transactions.write().unwrap();
             for tx in &block.transactions {
                 transaction_cache.pop(&tx.hash());
             }
 
-            self.block_hashes.lock().pop(&block.header.hash());
-            self.blocks.lock().pop(&block.header.number);
+            self.block_hashes.write().unwrap().pop(&block.header.hash());
+            self.blocks.write().unwrap().pop(&block.header.number);
 
             let previous_block = self.get_block_by_hash(&block.header.parent_hash)?;
             self.put_latest_block(previous_block.as_ref())?;
         }
         Ok(())
     }
 }
-
-impl Cache {
-    pub fn get_code_by_hash(&self, hash: &H256) -> Result<Option<Vec<u8>>> {
-        Ok(self.contract_code.lock().get(hash).map(ToOwned::to_owned))
-    }
-
-    pub fn put_code(&self, hash: H256, code: &[u8]) -> Result<()> {
-        self.contract_code.lock().put(hash, code.to_vec());
-        Ok(())
-    }
-}

lib/ain-evm/src/storage/mod.rs

@@ -193,17 +193,7 @@ impl FlushableStorage for Storage {
 
 impl Storage {
     pub fn get_code_by_hash(&self, address: H160, hash: H256) -> Result<Option<Vec<u8>>> {
-        match self.cache.get_code_by_hash(&hash) {
-            Ok(Some(code)) => Ok(Some(code)),
-            Ok(None) => {
-                let code = self.blockstore.get_code_by_hash(address, &hash);
-                if let Ok(Some(ref code)) = code {
-                    self.cache.put_code(hash, code)?;
-                }
-                code
-            }
-            Err(e) => Err(e),
-        }
+        self.blockstore.get_code_by_hash(address, &hash)
     }
 
     pub fn put_code(

lib/ain-ocean/Cargo.toml

@@ -15,3 +15,17 @@ thiserror.workspace = true
 hex.workspace = true
 dftx-rs.workspace = true
 bitcoin.workspace = true
+tarpc = { version = "0.33", features = ["tokio1", "serde1", "serde-transport","tcp"] }
+tokio = { version = "1", features = ["full"] }
+serde_json = "1.0"
+json = "0.12.4"
+tokio-serde = {version="0.8.0"}
+futures = "0.3.29"
+jsonrpsee =  { version = "0.20.3", features = ["server", "macros", "http-client", "jsonrpsee-server"] }
+rocksdb = "0.21.0"
+ctrlc = "3.1.9"
+tempdir = "0.3.7"
+bitcoin_hashes = "0.12.0"
+structopt = { version = "0.3", default-features = false }
+tempfile = "3.8.1"
+anyhow.workspace = true

lib/ain-ocean/src/api/block.rs

@@ -1,4 +1,9 @@
-use axum::{debug_handler, extract::{Path, Query}, Json, routing::get, Router};
+use axum::{
+    debug_handler,
+    extract::{Path, Query},
+    routing::get,
+    Json, Router,
+};
 use serde::{Deserialize, Serialize};
 
 use crate::api_paged_response::ApiPagedResponse;
@@ -16,7 +21,7 @@ struct BlockHash {
 #[derive(Deserialize)]
 pub struct ListBlocksQuery {
     pub size: usize,
-    pub next: Option<String>
+    pub next: Option<String>,
 }
 
 #[debug_handler]
@@ -28,14 +33,10 @@ async fn list_blocks(Query(query): Query<ListBlocksQuery>) -> Json<ApiPagedRespo
         Block { id: "1".into() },
         Block { id: "2".into() },
     ];
-
-    Json(ApiPagedResponse
-        ::of(
-            blocks,
-            query.size, 
-            |block| block.clone().id
-        )
-    )
+
+    Json(ApiPagedResponse::of(blocks, query.size, |block| {
+        block.clone().id
+    }))
 }
 
 async fn get_block(Path(BlockId { id }): Path<BlockId>) -> String {
@@ -60,24 +61,24 @@ pub struct Block {
     // TODO(): type mapping
     // hash: H256,
     // previous_hash: H256,
-    
+
     // height: u64,
     // version: u64,
     // time: u64, // ---------------| block time in seconds since epoch
     // median_time: u64, // --------| meidan time of the past 11 block timestamps
-    
+
     // transaction_count: u64,
 
     // difficulty: u64,
-    
+
     // masternode: H256,
     // minter: H256,
     // minter_block_count: u64,
     // reward: f64
-    
+
     // state_modifier: H256,
     // merkle_root: H256,
-    
+
     // size: u64,
     // size_stripped: u64,
     // weight: u64,