Use a separate database for each data domain

CHANGELOG.md

@@ -27,7 +27,8 @@ Description of the upcoming release here.
 
 #### Breaking
 - [#1639](https://github.com/FuelLabs/fuel-core/pull/1639): Make Merkle metadata, i.e. `SparseMerkleMetadata` and `DenseMerkleMetadata` type version-able enums
-- [#16232](https://github.com/FuelLabs/fuel-core/pull/1632): Make `Message` type a version-able enum
+- [#1632](https://github.com/FuelLabs/fuel-core/pull/1632): Make `Message` type a version-able enum
+- [#1629](https://github.com/FuelLabs/fuel-core/pull/1629): Use a separate database for each data domain. Each database has its own folder where data is stored.
 - [#1628](https://github.com/FuelLabs/fuel-core/pull/1628): Make `CompressedCoin` type a version-able enum
 - [#1616](https://github.com/FuelLabs/fuel-core/pull/1616): Make `BlockHeader` type a version-able enum
 - [#1614](https://github.com/FuelLabs/fuel-core/pull/1614): Use the default consensus key regardless of trigger mode. The change is breaking because it removes the `--dev-keys` argument. If the `debug` flag is set, the default consensus key will be used, regardless of the trigger mode.

benches/benches/block_target_gas.rs

@@ -16,6 +16,7 @@ use criterion::{
 use ed25519_dalek::Signer;
 use ethnum::U256;
 use fuel_core::{
+    combined_database::CombinedDatabase,
     service::{
         config::Trigger,
         Config,
@@ -325,8 +326,11 @@ fn service_with_many_contracts(
             .unwrap();
     }
 
-    let service = fuel_core::service::FuelService::new(database, config.clone())
-        .expect("Unable to start a FuelService");
+    let service = FuelService::new(
+        CombinedDatabase::new(database, Default::default(), Default::default()),
+        config.clone(),
+    )
+    .expect("Unable to start a FuelService");
     service.start().expect("Unable to start the service");
     (service, rt)
 }
@@ -456,6 +460,7 @@ fn replace_contract_in_service(
     service
         .shared
         .database
+        .on_chain_mut()
         .storage_as_mut::<ContractsRawCode>()
         .insert(contract_id, &contract_bytecode)
         .unwrap();

benches/benches/transaction_throughput.rs

@@ -112,6 +112,7 @@ where
                             let block = srv
                                 .shared
                                 .database
+                                .on_chain()
                                 .get_sealed_block_by_height(&1.into())
                                 .unwrap()
                                 .unwrap();

crates/fuel-core/Cargo.toml

@@ -46,6 +46,7 @@ rocksdb = { version = "0.21", default-features = false, features = [
     "lz4",
     "multi-threaded-cf",
 ], optional = true }
+serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["raw_value"] }
 strum = { workspace = true }
 strum_macros = { workspace = true }

crates/fuel-core/src/coins_query.rs

@@ -228,7 +228,7 @@ mod tests {
             CoinsQueryError,
             SpendQuery,
         },
-        database::Database,
+        combined_database::CombinedDatabase,
         fuel_core_graphql_api::api_service::ReadDatabase as ServiceDatabase,
         query::asset_query::{
             AssetQuery,
@@ -922,7 +922,7 @@ mod tests {
     }
 
     pub struct TestDatabase {
-        database: Database,
+        database: CombinedDatabase,
         last_coin_index: u64,
         last_message_index: u64,
     }
@@ -937,8 +937,9 @@ mod tests {
         }
 
         fn service_database(&self) -> ServiceDatabase {
-            let database = self.database.clone();
-            ServiceDatabase::new(database.clone(), database)
+            let on_chain = self.database.on_chain().clone();
+            let off_chain = self.database.off_chain().clone();
+            ServiceDatabase::new(on_chain, off_chain)
         }
     }
 
@@ -958,7 +959,7 @@ mod tests {
             coin.set_amount(amount);
             coin.set_asset_id(asset_id);
 
-            let db = &mut self.database;
+            let db = self.database.on_chain_mut();
             StorageMutate::<Coins>::insert(db, &id, &coin).unwrap();
 
             coin.uncompress(id)
@@ -978,7 +979,7 @@ mod tests {
             }
             .into();
 
-            let db = &mut self.database;
+            let db = self.database.on_chain_mut();
             StorageMutate::<Messages>::insert(db, message.id(), &message).unwrap();
 
             message

crates/fuel-core/src/combined_database.rs

@@ -0,0 +1,92 @@
+use crate::database::{
+    database_description::{
+        off_chain::OffChain,
+        on_chain::OnChain,
+        relayer::Relayer,
+    },
+    Database,
+    Result as DatabaseResult,
+};
+use fuel_core_storage::Result as StorageResult;
+use fuel_core_types::{
+    blockchain::primitives::DaBlockHeight,
+    fuel_types::BlockHeight,
+};
+
+/// A database that combines the on-chain, off-chain and relayer databases into one entity.
+#[derive(Default, Clone)]
+pub struct CombinedDatabase {
+    on_chain: Database<OnChain>,
+    off_chain: Database<OffChain>,
+    relayer: Database<Relayer>,
+}
+
+impl CombinedDatabase {
+    pub fn new(
+        on_chain: Database<OnChain>,
+        off_chain: Database<OffChain>,
+        relayer: Database<Relayer>,
+    ) -> Self {
+        Self {
+            on_chain,
+            off_chain,
+            relayer,
+        }
+    }
+
+    #[cfg(feature = "rocksdb")]
+    pub fn open(path: &std::path::Path, capacity: usize) -> DatabaseResult<Self> {
+        // TODO: Use different cache sizes for different databases
+        let on_chain = Database::open(path, capacity)?;
+        let off_chain = Database::open(path, capacity)?;
+        let relayer = Database::open(path, capacity)?;
+        Ok(Self {
+            on_chain,
+            off_chain,
+            relayer,
+        })
+    }
+
+    pub fn in_memory() -> Self {
+        Self::new(
+            Database::in_memory(),
+            Database::in_memory(),
+            Database::in_memory(),
+        )
+    }
+
+    pub fn init(
+        &mut self,
+        block_height: &BlockHeight,
+        da_block_height: &DaBlockHeight,
+    ) -> StorageResult<()> {
+        self.on_chain.init(block_height)?;
+        self.off_chain.init(block_height)?;
+        self.relayer.init(da_block_height)?;
+        Ok(())
+    }
+
+    pub fn on_chain(&self) -> &Database<OnChain> {
+        &self.on_chain
+    }
+
+    #[cfg(any(feature = "test-helpers", test))]
+    pub fn on_chain_mut(&mut self) -> &mut Database<OnChain> {
+        &mut self.on_chain
+    }
+
+    pub fn off_chain(&self) -> &Database<OffChain> {
+        &self.off_chain
+    }
+
+    pub fn relayer(&self) -> &Database<Relayer> {
+        &self.relayer
+    }
+
+    pub fn flush(self) -> DatabaseResult<()> {
+        self.on_chain.flush()?;
+        self.off_chain.flush()?;
+        self.relayer.flush()?;
+        Ok(())
+    }
+}