refactor: rename era2 to e2ss (#1656)

Author: KolbyML

bin/portal-bridge/src/bridge/state.rs

@@ -6,7 +6,7 @@ use std::{
 
 use alloy::{consensus::EMPTY_ROOT_HASH, rlp::Decodable};
 use anyhow::ensure;
-use e2store::utils::get_era2_files;
+use e2store::utils::get_e2ss_files;
 use eth_trie::{decode_node, node::Node, EthTrie, RootWithTrieDiff, Trie};
 use ethportal_api::{
     jsonrpsee::http_client::HttpClient,
@@ -41,7 +41,7 @@ use trin_execution::{
         account_db::AccountDB, evm_db::EvmDB, execution_position::ExecutionPosition,
         utils::setup_rocksdb,
     },
-    subcommands::era2::{
+    subcommands::e2ss::{
         import::StateImporter,
         utils::{download_with_progress, percentage_from_address_hash},
     },
@@ -177,7 +177,7 @@ impl StateBridge {
     async fn launch_snapshot(&self, snapshot_block: u64) -> anyhow::Result<()> {
         ensure!(snapshot_block > 0, "Snapshot block must be greater than 0");
 
-        // 1. Download the era2 file and import the state snapshot
+        // 1. Download the e2ss file and import the state snapshot
         let data_dir = setup_data_dir(APP_NAME, self.data_dir.clone(), false)?;
         let next_block_number = {
             let rocks_db = Arc::new(setup_rocksdb(&data_dir)?);
@@ -201,36 +201,36 @@ impl StateBridge {
                 )]))
                 .build()?;
 
-            let era2_files = get_era2_files(&http_client).await?;
-            let era2_blocks = era2_files.keys().cloned().collect::<Vec<_>>();
+            let e2ss_files = get_e2ss_files(&http_client).await?;
+            let e2ss_blocks = e2ss_files.keys().cloned().collect::<Vec<_>>();
 
             ensure!(
-                era2_files.contains_key(&snapshot_block),
-                "Era2 file doesn't exist for requested snapshot block: try these {era2_blocks:?}"
+                e2ss_files.contains_key(&snapshot_block),
+                "E2SS file doesn't exist for requested snapshot block: try these {e2ss_blocks:?}"
             );
 
             info!(
-                "Downloading era2 file for snapshot block: {}",
+                "Downloading e2ss file for snapshot block: {}",
                 snapshot_block
             );
 
-            let path_to_era2 = data_dir.join(format!("era2-{snapshot_block}.bin"));
+            let path_to_e2ss = data_dir.join(format!("e2ss-{snapshot_block}.bin"));
             if let Err(e) = download_with_progress(
                 &http_client,
-                &era2_files[&snapshot_block],
-                path_to_era2.clone(),
+                &e2ss_files[&snapshot_block],
+                path_to_e2ss.clone(),
             )
             .await
             {
-                return Err(anyhow::anyhow!("Failed to download era2 file: {e}"));
+                return Err(anyhow::anyhow!("Failed to download e2ss file: {e}"));
             };
 
-            let import_state_config = ImportStateConfig { path_to_era2 };
+            let import_state_config = ImportStateConfig { path_to_e2ss };
 
             let state_importer = StateImporter::new(import_state_config, &data_dir).await?;
             let header = state_importer.import().await?;
             info!(
-                "Imported state from era2: {} {}",
+                "Imported state from e2ss: {} {}",
                 header.number, header.state_root,
             );
         }

bin/trin-execution/src/cli.rs

@@ -48,20 +48,20 @@ pub struct TrinExecutionConfig {
 #[derive(Subcommand, Debug, Clone, PartialEq)]
 #[allow(clippy::enum_variant_names)]
 pub enum TrinExecutionSubCommands {
-    /// Import a era2 state snapshot from a file, useful for bootstrapping a new node quickly
+    /// Import a e2ss state snapshot from a file, useful for bootstrapping a new node quickly
     ImportState(ImportStateConfig),
-    /// Export the current state of the node to a era2 file
+    /// Export the current state of the node to a e2ss file
     ExportState(ExportStateConfig),
 }
 
 #[derive(Args, Debug, Default, Clone, PartialEq)]
 pub struct ImportStateConfig {
-    #[arg(long, help = "path to where the era2 state snapshot is located")]
-    pub path_to_era2: PathBuf,
+    #[arg(long, help = "path to where the e2ss state snapshot is located")]
+    pub path_to_e2ss: PathBuf,
 }
 
 #[derive(Args, Debug, Default, Clone, PartialEq)]
 pub struct ExportStateConfig {
-    #[arg(long, help = "path to where the era2 state snapshot is located")]
-    pub path_to_era2: PathBuf,
+    #[arg(long, help = "path to where the e2ss state snapshot is located")]
+    pub path_to_e2ss: PathBuf,
 }

bin/trin-execution/src/main.rs

@@ -3,7 +3,7 @@ use tracing::info;
 use trin_execution::{
     cli::{TrinExecutionConfig, TrinExecutionSubCommands, APP_NAME},
     execution::TrinExecution,
-    subcommands::era2::{export::StateExporter, import::StateImporter},
+    subcommands::e2ss::{export::StateExporter, import::StateImporter},
 };
 use trin_utils::{dir::setup_data_dir, log::init_tracing_logger};
 
@@ -32,7 +32,7 @@ async fn main() -> anyhow::Result<()> {
                 let state_importer = StateImporter::new(import_state_config, &data_dir).await?;
                 let header = state_importer.import().await?;
                 info!(
-                    "Imported state from era2: {} {}",
+                    "Imported state from e2ss: {} {}",
                     header.number, header.state_root,
                 );
                 return Ok(());
@@ -41,7 +41,7 @@ async fn main() -> anyhow::Result<()> {
                 let state_exporter = StateExporter::new(export_state_config, &data_dir).await?;
                 state_exporter.export()?;
                 info!(
-                    "Exported state into era2: {} {}",
+                    "Exported state into e2ss: {} {}",
                     state_exporter.header().number,
                     state_exporter.header().state_root,
                 );

bin/trin-execution/src/subcommands/era2/export.rs renamed to bin/trin-execution/src/subcommands/e2ss/export.rs

@@ -5,8 +5,8 @@ use std::{
 
 use alloy::{consensus::EMPTY_ROOT_HASH, rlp::Decodable};
 use anyhow::ensure;
-use e2store::era2::{
-    AccountEntry, AccountOrStorageEntry, Era2Writer, StorageEntry, StorageItem, MAX_STORAGE_ITEMS,
+use e2store::e2ss::{
+    AccountEntry, AccountOrStorageEntry, E2SSWriter, StorageEntry, StorageItem, MAX_STORAGE_ITEMS,
 };
 use eth_trie::{EthTrie, Trie};
 use ethportal_api::{types::state_trie::account_state::AccountState, Header};
@@ -22,7 +22,7 @@ use crate::{
         account_db::AccountDB, evm_db::EvmDB, execution_position::ExecutionPosition,
         utils::setup_rocksdb,
     },
-    subcommands::era2::utils::percentage_from_address_hash,
+    subcommands::e2ss::utils::percentage_from_address_hash,
 };
 
 pub struct StateExporter {
@@ -69,8 +69,8 @@ impl StateExporter {
             "Exporting state from block number: {} with state root: {}",
             self.header.number, self.header.state_root
         );
-        let mut era2 = Era2Writer::create(&self.config.path_to_era2, self.header.clone())?;
-        info!("Era2 initiated");
+        let mut e2ss = E2SSWriter::create(&self.config.path_to_e2ss, self.header.clone())?;
+        info!("E2SS initiated");
         info!("Trie leaf iterator initiated");
         let mut accounts_exported = 0;
         for key_hash_and_leaf_value in self.evm_db.trie.lock().iter() {
@@ -109,15 +109,15 @@ impl StateExporter {
             // Get the rounded up storage count
             let storage_count = storage.len().div_ceil(MAX_STORAGE_ITEMS);
 
-            era2.append_entry(&AccountOrStorageEntry::Account(AccountEntry {
+            e2ss.append_entry(&AccountOrStorageEntry::Account(AccountEntry {
                 address_hash: account_hash,
                 account_state,
                 bytecode,
                 storage_count: storage_count as u32,
             }))?;
 
             for storage_chunk in storage.chunks(MAX_STORAGE_ITEMS) {
-                era2.append_entry(&AccountOrStorageEntry::Storage(StorageEntry(
+                e2ss.append_entry(&AccountOrStorageEntry::Storage(StorageEntry(
                     storage_chunk.to_vec(),
                 )))?;
             }
@@ -128,11 +128,11 @@ impl StateExporter {
             }
         }
 
-        era2.flush()?;
+        e2ss.flush()?;
 
-        info!("Era2 snapshot exported");
+        info!("E2SS snapshot exported");
 
-        Ok(era2.path().to_path_buf())
+        Ok(e2ss.path().to_path_buf())
     }
 
     pub fn header(&self) -> &Header {

bin/trin-execution/src/subcommands/era2/import.rs renamed to bin/trin-execution/src/subcommands/e2ss/import.rs

@@ -1,7 +1,7 @@
 use std::{path::Path, sync::Arc};
 
 use anyhow::{ensure, Error};
-use e2store::era2::{AccountEntry, AccountOrStorageEntry, Era2Reader, StorageItem};
+use e2store::e2ss::{AccountEntry, AccountOrStorageEntry, E2SSReader, StorageItem};
 use eth_trie::{EthTrie, Trie};
 use ethportal_api::Header;
 use revm_primitives::{keccak256, B256, U256};
@@ -16,7 +16,7 @@ use crate::{
         account_db::AccountDB, evm_db::EvmDB, execution_position::ExecutionPosition,
         utils::setup_rocksdb,
     },
-    subcommands::era2::utils::percentage_from_address_hash,
+    subcommands::e2ss::utils::percentage_from_address_hash,
 };
 
 pub struct StateImporter {
@@ -31,7 +31,7 @@ impl StateImporter {
         let execution_position = ExecutionPosition::initialize_from_db(rocks_db.clone())?;
         ensure!(
             execution_position.next_block_number() == 0,
-            "Cannot import state from .era2, database is not empty",
+            "Cannot import state from .e2ss, database is not empty",
         );
 
         let evm_db = EvmDB::new(StateConfig::default(), rocks_db, &execution_position)
@@ -41,7 +41,7 @@ impl StateImporter {
     }
 
     pub async fn import(&self) -> anyhow::Result<Header> {
-        // Import state from era2 file
+        // Import state from e2ss file
         let header = self.import_state()?;
 
         // Save execution position
@@ -55,12 +55,12 @@ impl StateImporter {
     }
 
     fn import_state(&self) -> anyhow::Result<Header> {
-        info!("Importing state from .era2 file");
+        info!("Importing state from .e2ss file");
 
-        let mut era2 = Era2Reader::open(&self.config.path_to_era2)?;
-        info!("Era2 reader initiated");
+        let mut e2ss = E2SSReader::open(&self.config.path_to_e2ss)?;
+        info!("E2SS reader initiated");
         let mut accounts_imported = 0;
-        while let Some(account) = era2.next() {
+        while let Some(account) = e2ss.next() {
             let AccountOrStorageEntry::Account(account) = account else {
                 return Err(Error::msg("Expected account, got storage entry"));
             };
@@ -75,7 +75,7 @@ impl StateImporter {
             let account_db = AccountDB::new(address_hash, self.evm_db.db.clone());
             let mut storage_trie = EthTrie::new(Arc::new(account_db));
             for _ in 0..storage_count {
-                let Some(AccountOrStorageEntry::Storage(storage_entry)) = era2.next() else {
+                let Some(AccountOrStorageEntry::Storage(storage_entry)) = e2ss.next() else {
                     return Err(Error::msg("Expected storage, got account entry"));
                 };
                 for StorageItem {
@@ -92,13 +92,13 @@ impl StateImporter {
             }
 
             if storage_trie.root_hash()? != account_state.storage_root {
-                return Err(Error::msg("Failed importing account storage trie: storage roots don't match expect value, .era2 import failed"));
+                return Err(Error::msg("Failed importing account storage trie: storage roots don't match expect value, .e2ss import failed"));
             }
 
             // Insert contract if available
             ensure!(
                 account_state.code_hash == keccak256(&bytecode),
-                "Code hash mismatch, .era2 import failed"
+                "Code hash mismatch, .e2ss import failed"
             );
             if !bytecode.is_empty() {
                 self.evm_db.db.put(keccak256(&bytecode), bytecode.clone())?;
@@ -125,15 +125,15 @@ impl StateImporter {
             }
         }
 
-        // Check if the state root matches, if this fails it means either the .era2 is wrong or we
+        // Check if the state root matches, if this fails it means either the .e2ss is wrong or we
         // imported the state wrong
-        if era2.header.header.state_root != self.evm_db.trie.lock().root_hash()? {
-            return Err(Error::msg("State root mismatch, .era2 import failed"));
+        if e2ss.header.header.state_root != self.evm_db.trie.lock().root_hash()? {
+            return Err(Error::msg("State root mismatch, .e2ss import failed"));
         }
 
-        info!("Done importing State from .era2 file");
+        info!("Done importing State from .e2ss file");
 
-        Ok(era2.header.header)
+        Ok(e2ss.header.header)
     }
 
     /// insert the last 256 block hashes into the database

bin/trin-execution/src/subcommands/era2/mod.rs renamed to bin/trin-execution/src/subcommands/e2ss/mod.rs

@@ -1 +1 @@
-pub mod era2;
+pub mod e2ss;

bin/trin-execution/src/subcommands/era2/utils.rs renamed to bin/trin-execution/src/subcommands/e2ss/utils.rs

@@ -4,16 +4,16 @@ use trin_execution::{
     cli::{ExportStateConfig, ImportStateConfig},
     config::StateConfig,
     execution::TrinExecution,
-    subcommands::era2::{export::StateExporter, import::StateImporter},
+    subcommands::e2ss::{export::StateExporter, import::StateImporter},
 };
 use trin_utils::dir::create_temp_test_dir;
 
-/// Tests that exporting/importing to/from era2 files works.
+/// Tests that exporting/importing to/from e2ss files works.
 ///
 /// This test does the following:
 /// 1. executes first `blocks` blocks
-/// 2. exports state to the era2
-/// 3. imports state from era2 file into new directory
+/// 2. exports state to the e2ss
+/// 3. imports state from e2ss file into new directory
 /// 4. executes another `blocks` blocks
 ///
 /// Following command can be used to run the test for different number of blocks (e.g. 10000):
@@ -32,7 +32,7 @@ async fn execute_export_import_execute() -> anyhow::Result<()> {
     info!("Running test for {blocks} blocks");
 
     let temp_directory = create_temp_test_dir()?;
-    let era2_dir = temp_directory.path().join("era");
+    let e2ss_dir = temp_directory.path().join("era");
     let dir_1 = temp_directory.path().join("dir_1");
     let dir_2 = temp_directory.path().join("dir_2");
 
@@ -44,21 +44,21 @@ async fn execute_export_import_execute() -> anyhow::Result<()> {
     assert_eq!(trin_execution.next_block_number(), blocks + 1);
     drop(trin_execution);
 
-    // 2. export from dir_1 into era2
+    // 2. export from dir_1 into e2ss
     let exporter = StateExporter::new(
         ExportStateConfig {
-            path_to_era2: era2_dir,
+            path_to_e2ss: e2ss_dir,
         },
         &dir_1,
     )
     .await?;
-    let era2_file = exporter.export()?;
+    let e2ss_file = exporter.export()?;
     drop(exporter);
 
-    // 3. import from era2 into dir_2
+    // 3. import from e2ss into dir_2
     let importer = StateImporter::new(
         ImportStateConfig {
-            path_to_era2: era2_file,
+            path_to_e2ss: e2ss_file,
         },
         &dir_2,
     )

bin/trin-execution/src/subcommands/mod.rs

@@ -33,8 +33,8 @@ tokio.workspace = true
 trin-utils.workspace = true
 
 [features]
-era2-stats-binary = ["clap", "tracing", "trin-utils"]
+e2ss-stats-binary = ["clap", "tracing", "trin-utils"]
 
 [[bin]]
-name = "era2-stats"
-required-features = ["era2-stats-binary"]
+name = "e2ss-stats"
+required-features = ["e2ss-stats-binary"]