Merge branch 'main' into fix/get_class

.vscode/launch.json

@@ -25,8 +25,7 @@
         "--rpc-cors",
         "all",
         "--pruning",
-        "archive",
-        "--cache"
+        "archive"
       ],
       // Working folder for execution. Change as necessary if program requires a different value:
       "cwd": "${workspaceFolder}",

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## Next release
 
-- fix(rpx): get_class
+- fix(rpc): get_class
+- refactor: mapping db
 - perf(db): contract key history now using rocksdb iterators for history
 - fix(root): Cleaned state root commitments crate
 - fix(hash): declare tx v0 hash computation

crates/client/db/src/lib.rs

@@ -133,13 +133,20 @@ fn spawn_backup_db_task(
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum Column {
     Meta,
+    // Starknet block hash to Substrate block hash
     BlockMapping,
-    TransactionMapping,
+    // Substrate block hash to true if it contains a Starknet block
     SyncedMapping,
-    BlockHashToNumber,
-    BlockNumberToHash,
-    BlockStateDiff,
-
+    // Transaction hash to Substrate block hash
+    TransactionMapping,
+    /// Starknet block hash to list of starknet transaction hashes
+    StarknetTransactionHashesMapping,
+    /// Block number to block Starknet block hash
+    StarknetBlockHashesMapping,
+    /// Starknet block hash to block number
+    StarknetBlockNumberMapping,
+
+    /// Contract class hash to class data
     ContractClassData,
 
     // History of contract class hashes
@@ -156,17 +163,8 @@ pub enum Column {
     // History of contract key => values
     // (contract_address, storage_key) history block_number => felt
     ContractStorage,
-
-    /// This column is used to map starknet block hashes to a list of transaction hashes that are
-    /// contained in the block.
-    ///
-    /// This column should only be accessed if the `--cache` flag is enabled.
-    StarknetTransactionHashesCache,
-
-    /// This column is used to map starknet block numbers to their block hashes.
-    ///
-    /// This column should only be accessed if the `--cache` flag is enabled.
-    StarknetBlockHashesCache,
+    /// Block number to state diff
+    BlockStateDiff,
 
     // Each bonsai storage has 3 columns
     BonsaiContractsTrie,
@@ -182,6 +180,12 @@ pub enum Column {
     BonsaiClassesLog,
 }
 
+impl Column {
+    fn iter() -> impl Iterator<Item = Self> {
+        Self::ALL.iter().copied()
+    }
+}
+
 impl fmt::Debug for Column {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.rocksdb_name())
@@ -200,18 +204,17 @@ impl Column {
         &[
             Meta,
             BlockMapping,
-            TransactionMapping,
             SyncedMapping,
-            BlockHashToNumber,
-            BlockNumberToHash,
-            BlockStateDiff,
+            TransactionMapping,
+            StarknetTransactionHashesMapping,
+            StarknetBlockHashesMapping,
+            StarknetBlockNumberMapping,
             ContractClassData,
             ContractToClassHashes,
             ContractToNonces,
             ContractClassHashes,
             ContractStorage,
-            StarknetTransactionHashesCache,
-            StarknetBlockHashesCache,
+            BlockStateDiff,
             BonsaiContractsTrie,
             BonsaiContractsFlat,
             BonsaiContractsLog,
@@ -232,8 +235,9 @@ impl Column {
             BlockMapping => "block_mapping",
             TransactionMapping => "transaction_mapping",
             SyncedMapping => "synced_mapping",
-            StarknetTransactionHashesCache => "starknet_transaction_hashes_cache",
-            StarknetBlockHashesCache => "starnet_block_hashes_cache",
+            StarknetTransactionHashesMapping => "starknet_transaction_hashes_mapping",
+            StarknetBlockHashesMapping => "starnet_block_hashes_mapping",
+            StarknetBlockNumberMapping => "starknet_block_number_mapping",
             BonsaiContractsTrie => "bonsai_contracts_trie",
             BonsaiContractsFlat => "bonsai_contracts_flat",
             BonsaiContractsLog => "bonsai_contracts_log",
@@ -243,14 +247,12 @@ impl Column {
             BonsaiClassesTrie => "bonsai_classes_trie",
             BonsaiClassesFlat => "bonsai_classes_flat",
             BonsaiClassesLog => "bonsai_classes_log",
-            BlockHashToNumber => "block_hash_to_number_trie",
-            BlockNumberToHash => "block_to_hash_trie",
             BlockStateDiff => "block_state_diff",
             ContractClassData => "contract_class_data",
             ContractToClassHashes => "contract_to_class_hashes",
             ContractToNonces => "contract_to_nonces",
             ContractClassHashes => "contract_class_hashes",
-            ContractStorage => "contract_storage",
+            ContractStorage => "contrac_storage",
         }
     }
 
@@ -346,7 +348,6 @@ impl DeoxysBackend {
         db_config_dir: &Path,
         backup_dir: Option<PathBuf>,
         restore_from_latest_backup: bool,
-        cache_more_things: bool,
     ) -> Result<&'static Arc<DeoxysBackend>> {
         let db_path = db_config_dir.join("starknet/rockdb"); //.deoxysdb/chains/starknet/starknet/rockdb
 
@@ -404,7 +405,7 @@ impl DeoxysBackend {
         bonsai_classes.init_tree(bonsai_identifier::CLASS).unwrap();
 
         let backend = Arc::new(Self {
-            mapping: Arc::new(MappingDb::new(Arc::clone(db), cache_more_things)),
+            mapping: Arc::new(MappingDb::new(Arc::clone(db))),
             meta: Arc::new(MetaDb::new(Arc::clone(db))),
             bonsai_contract: RwLock::new(bonsai_contract),
             bonsai_storage: RwLock::new(bonsai_contract_storage),

crates/client/db/src/mapping_db.rs

@@ -21,14 +21,12 @@ pub struct MappingCommitment<B: BlockT> {
 /// Allow interaction with the mapping db
 pub struct MappingDb {
     db: Arc<DB>,
-    /// Whether more information should be cached in the database.
-    cache_more_things: bool,
 }
 
 impl MappingDb {
     /// Creates a new instance of the mapping database.
-    pub(crate) fn new(db: Arc<DB>, cache_more_things: bool) -> Self {
-        Self { db, cache_more_things }
+    pub(crate) fn new(db: Arc<DB>) -> Self {
+        Self { db }
     }
 
     /// Check if the given block hash has already been processed
@@ -45,7 +43,7 @@ impl MappingDb {
     ///
     /// Under some circumstances it can return multiples blocks hashes, meaning that the result has
     /// to be checked against the actual blockchain state in order to find the good one.
-    pub fn block_hash(&self, starknet_block_hash: StarkHash) -> Result<Option<Vec<DHashT>>, DbError> {
+    pub fn substrate_block_hash(&self, starknet_block_hash: StarkHash) -> Result<Option<Vec<DHashT>>, DbError> {
         let block_mapping_col = self.db.get_column(Column::BlockMapping);
 
         match self.db.get_cf(&block_mapping_col, starknet_block_hash.encode())? {
@@ -67,12 +65,13 @@ impl MappingDb {
         let synced_mapping_col = self.db.get_column(Column::SyncedMapping);
         let block_mapping_col = self.db.get_column(Column::BlockMapping);
         let transaction_mapping_col = self.db.get_column(Column::TransactionMapping);
-        let starknet_tx_hashes_col = self.db.get_column(Column::StarknetTransactionHashesCache);
-        let starknet_block_hashes_col = self.db.get_column(Column::StarknetBlockHashesCache);
+        let starknet_tx_hashes_col = self.db.get_column(Column::StarknetTransactionHashesMapping);
+        let starknet_block_hashes_col = self.db.get_column(Column::StarknetBlockHashesMapping);
+        let starknet_block_numbers_col = self.db.get_column(Column::StarknetBlockNumberMapping);
 
         let mut transaction: WriteBatchWithTransaction<true> = Default::default();
 
-        let substrate_hashes = match self.block_hash(commitment.starknet_block_hash) {
+        let substrate_hashes = match self.substrate_block_hash(commitment.starknet_block_hash) {
             Ok(Some(mut data)) => {
                 data.push(commitment.block_hash);
                 // log::warn!(
@@ -94,19 +93,22 @@ impl MappingDb {
             transaction.put_cf(&transaction_mapping_col, &transaction_hash.encode(), &commitment.block_hash.encode());
         }
 
-        if self.cache_more_things {
-            transaction.put_cf(
-                &starknet_tx_hashes_col,
-                &commitment.starknet_block_hash.encode(),
-                &commitment.starknet_transaction_hashes.encode(),
-            );
-
-            transaction.put_cf(
-                &starknet_block_hashes_col,
-                &commitment.block_number.encode(),
-                &commitment.starknet_block_hash.encode(),
-            );
-        }
+        transaction.put_cf(
+            &starknet_tx_hashes_col,
+            &commitment.starknet_block_hash.encode(),
+            &commitment.starknet_transaction_hashes.encode(),
+        );
+
+        transaction.put_cf(
+            &starknet_block_hashes_col,
+            &commitment.block_number.encode(),
+            &commitment.starknet_block_hash.encode(),
+        );
+        transaction.put_cf(
+            &starknet_block_numbers_col,
+            &commitment.starknet_block_hash.encode(),
+            &commitment.block_number.encode(),
+        );
 
         self.db.write(transaction)?;
 
@@ -121,7 +123,10 @@ impl MappingDb {
     /// * `transaction_hash` - the transaction hash to search for. H256 is used here because it's a
     ///   native type of substrate, and we are sure it's SCALE encoding is optimized and will not
     ///   change.
-    pub fn block_hash_from_transaction_hash(&self, transaction_hash: StarkHash) -> Result<Option<DHashT>, DbError> {
+    pub fn substrate_block_hash_from_transaction_hash(
+        &self,
+        transaction_hash: StarkHash,
+    ) -> Result<Option<DHashT>, DbError> {
         let transaction_mapping_col = self.db.get_column(Column::TransactionMapping);
 
         match self.db.get_cf(&transaction_mapping_col, transaction_hash.encode())? {
@@ -144,25 +149,18 @@ impl MappingDb {
     ///
     /// - The cache is disabled.
     /// - The provided `starknet_hash` is not present in the cache.
-    pub fn cached_transaction_hashes_from_block_hash(
+    pub fn transaction_hashes_from_block_hash(
         &self,
         starknet_block_hash: StarkHash,
     ) -> Result<Option<Vec<StarkHash>>, DbError> {
-        let starknet_tx_hashes_col = self.db.get_column(Column::StarknetTransactionHashesCache);
-
-        if !self.cache_more_things {
-            // The cache is not enabled, no need to even touch the database.
-            return Ok(None);
-        }
+        let starknet_tx_hashes_col = self.db.get_column(Column::StarknetTransactionHashesMapping);
 
         match self.db.get_cf(&starknet_tx_hashes_col, starknet_block_hash.encode())? {
             Some(raw) => Ok(Some(Vec::<StarkHash>::decode(&mut &raw[..])?)),
             None => Ok(None),
         }
     }
 
-    /// Returns the cached block hash of a given block number.
-    ///
     /// # Arguments
     ///
     /// * `block_number` - the block number to search for.
@@ -171,23 +169,34 @@ impl MappingDb {
     ///
     /// The block hash of a given block number.
     ///
-    /// This function may return `None` for two separate reasons:
-    ///
-    /// - The cache is disabled.
-    /// - The provided `starknet_hash` is not present in the cache.
-    pub fn cached_block_hash_from_block_number(
-        &self,
-        starknet_block_number: u64,
-    ) -> Result<Option<StarkHash>, DbError> {
-        let starknet_block_hashes_col = self.db.get_column(Column::StarknetBlockHashesCache);
+    /// This function may return `None` if the provided `block_number` is not present in the cache.
+    pub fn starknet_block_hash_from_block_number(&self, block_number: u64) -> Result<Option<StarkHash>, DbError> {
+        let starknet_block_hashes_col = self.db.get_column(Column::StarknetBlockHashesMapping);
 
-        if !self.cache_more_things {
-            // The cache is not enabled, no need to even touch the database.
-            return Ok(None);
+        match self.db.get_cf(&starknet_block_hashes_col, block_number.encode())? {
+            Some(raw) => Ok(Some(<StarkHash>::decode(&mut &raw[..])?)),
+            None => Ok(None),
         }
+    }
 
-        match self.db.get_cf(&starknet_block_hashes_col, starknet_block_number.encode())? {
-            Some(raw) => Ok(Some(<StarkHash>::decode(&mut &raw[..])?)),
+    /// # Arguments
+    ///
+    /// * `starknet_block_hash` - the block number to search for.
+    ///
+    /// # Returns
+    ///
+    /// The block hash of a given block number.
+    ///
+    /// This function may return `None` if the provided `starknet_block_hash` is not present in the
+    /// cache.
+    pub fn block_number_from_starknet_block_hash(
+        &self,
+        starknet_block_hash: StarkHash,
+    ) -> Result<Option<u64>, DbError> {
+        let starknet_block_numbers_col = self.db.get_column(Column::StarknetBlockNumberMapping);
+
+        match self.db.get_cf(&starknet_block_numbers_col, starknet_block_hash.encode())? {
+            Some(raw) => Ok(Some(u64::decode(&mut &raw[..])?)),
             None => Ok(None),
         }
     }