passing almost all integration tests

core/bin/external_node/src/config/mod.rs

@@ -1116,6 +1116,7 @@ impl ExperimentalENConfig {
             snapshots_recovery_tree_chunk_size: Self::default_snapshots_recovery_tree_chunk_size(),
             snapshots_recovery_tree_parallel_persistence_buffer: None,
             commitment_generator_max_parallelism: None,
+            snapshots_recovery_recover_from_l1: false,
         }
     }
 

core/bin/external_node/src/node_builder.rs

@@ -544,6 +544,7 @@ impl ExternalNodeBuilder {
                         .experimental
                         .snapshots_recovery_drop_storage_key_preimages,
                     object_store_config: config.optional.snapshots_recovery_object_store.clone(),
+                    recover_main_node_components: false,
                 });
         self.node.add_layer(ExternalNodeInitStrategyLayer {
             l2_chain_id: self.config.required.l2_chain_id,

core/bin/zksync_server/Cargo.toml

@@ -22,6 +22,7 @@ zksync_types.workspace = true
 zksync_core_leftovers.workspace = true
 zksync_node_genesis.workspace = true
 zksync_da_clients.workspace = true
+zksync_block_reverter.workspace = true
 
 # Consensus dependenices
 zksync_consensus_crypto.workspace = true

core/bin/zksync_server/src/main.rs

@@ -42,6 +42,8 @@ struct Cli {
     /// Generate genesis block for the first contract deployment using temporary DB.
     #[arg(long)]
     genesis: bool,
+    #[arg(long)]
+    l1_recovery: bool,
     /// Comma-separated list of components to launch.
     #[arg(
         long,
@@ -151,6 +153,12 @@ fn main() -> anyhow::Result<()> {
         return Ok(());
     }
 
+    if opt.l1_recovery {
+        // If genesis is requested, we don't need to run the node.
+        node.only_l1_recovery()?.run(observability_guard)?;
+        return Ok(());
+    }
+
     node.build(opt.components.0)?.run(observability_guard)?;
     Ok(())
 }

core/bin/zksync_server/src/node_builder.rs

@@ -622,10 +622,14 @@ impl MainNodeBuilder {
     ///
     /// This task works in pair with precondition, which must be present in every component:
     /// the precondition will prevent node from starting until the database is initialized.
-    fn add_storage_initialization_layer(mut self, kind: LayerKind) -> anyhow::Result<Self> {
+    fn add_storage_initialization_layer(
+        mut self,
+        kind: LayerKind,
+        l1_recovery: bool,
+    ) -> anyhow::Result<Self> {
         self.node.add_layer(MainNodeInitStrategyLayer {
             genesis: self.genesis_config.clone(),
-            l1_recovery_enabled: false,
+            l1_recovery_enabled: l1_recovery,
             contracts: self.contracts_config.clone(),
         });
         let mut layer = NodeStorageInitializerLayer::new();
@@ -641,7 +645,17 @@ impl MainNodeBuilder {
         self = self
             .add_pools_layer()?
             .add_query_eth_client_layer()?
-            .add_storage_initialization_layer(LayerKind::Task)?;
+            .add_storage_initialization_layer(LayerKind::Task, false)?;
+
+        Ok(self.node.build())
+    }
+
+    pub fn only_l1_recovery(mut self) -> anyhow::Result<ZkStackService> {
+        self = self
+            .add_pools_layer()?
+            .add_query_eth_client_layer()?
+            .add_healthcheck_layer()?
+            .add_storage_initialization_layer(LayerKind::Task, true)?;
 
         Ok(self.node.build())
     }
@@ -662,7 +676,7 @@ impl MainNodeBuilder {
         // Add preconditions for all the components.
         self = self
             .add_l1_batch_commitment_mode_validation_layer()?
-            .add_storage_initialization_layer(LayerKind::Precondition)?;
+            .add_storage_initialization_layer(LayerKind::Precondition, false)?;
 
         // Sort the components, so that the components they may depend on each other are added in the correct order.
         components.sort_unstable_by_key(|component| match component {
@@ -681,7 +695,7 @@ impl MainNodeBuilder {
                     // which is why we consider it to be responsible for the storage initialization.
                     self = self
                         .add_l1_gas_layer()?
-                        .add_storage_initialization_layer(LayerKind::Task)?
+                        .add_storage_initialization_layer(LayerKind::Task, false)?
                         .add_state_keeper_layer()?
                         .add_logs_bloom_backfill_layer()?;
                 }

core/lib/basic_types/src/web3/contract.rs

@@ -12,6 +12,8 @@ pub enum Error {
     Other(String),
 }
 
+use ethabi::{Token, Token::Uint};
+
 use crate::{H160, H256, U256};
 
 pub trait Detokenize: Sized {
@@ -178,6 +180,19 @@ impl<T: TokenizableItem> Tokenizable for Vec<T> {
     }
 }
 
+impl Detokenize for (u32, u32, u32) {
+    fn from_tokens(tokens: Vec<Token>) -> anyhow::Result<Self, Error> {
+        match tokens.as_slice() {
+            [Uint(val1), Uint(val2), Uint(val3)] => {
+                Ok((val1.as_u32(), val2.as_u32(), val3.as_u32()))
+            }
+            other => Err(Error::InvalidOutputType(format!(
+                "Expected 3-element `Tuple`, got {other:?}"
+            ))),
+        }
+    }
+}
+
 /// Marker trait for `Tokenizable` types that are can tokenized to and from a
 /// `Token::Array` and `Token:FixedArray`.
 pub trait TokenizableItem: Tokenizable {}

core/lib/dal/src/eth_sender_dal.rs

@@ -500,8 +500,8 @@ impl EthSenderDal<'_, '_> {
             // Insert a "sent transaction".
             let eth_history_id = sqlx::query_scalar!(
                 "INSERT INTO eth_txs_history \
-                (eth_tx_id, base_fee_per_gas, priority_fee_per_gas, tx_hash, signed_raw_tx, created_at, updated_at, confirmed_at) \
-                VALUES ($1, 0, 0, $2, '\\x00', now(), now(), $3) \
+                (eth_tx_id, base_fee_per_gas, priority_fee_per_gas, tx_hash, signed_raw_tx, sent_at_block, created_at, updated_at, confirmed_at) \
+                VALUES ($1, 0, 0, $2, '\\x00', 0, now(), now(), $3) \
                 RETURNING id",
                 eth_tx_id,
                 tx_hash,

core/lib/eth_client/src/clients/http/query.rs

@@ -179,12 +179,17 @@ where
                             let message_len =
                                 "execution reverted: ".len().min(call_err.message().len());
                             let revert_reason = call_err.message()[message_len..].to_string();
+                            let error_selector = call_err
+                                .data()
+                                .map(|x| x.to_string()[2..11].to_string())
+                                .unwrap_or_default();
 
                             Ok(Some(FailureInfo {
                                 revert_code,
                                 revert_reason,
                                 gas_used,
                                 gas_limit,
+                                error_selector,
                             }))
                         } else {
                             Err(err)

core/lib/eth_client/src/types.rs

@@ -316,6 +316,7 @@ pub struct FailureInfo {
     pub gas_used: Option<U256>,
     /// Gas limit of the transaction.
     pub gas_limit: U256,
+    pub error_selector: String,
 }
 
 #[cfg(test)]

core/lib/l1_contract_interface/Cargo.toml

@@ -24,6 +24,7 @@ sha2.workspace = true
 sha3.workspace = true
 hex.workspace = true
 once_cell.workspace = true
+tracing.workspace = true
 
 [dev-dependencies]
 rand.workspace = true

core/lib/mempool/src/mempool_store.rs

@@ -1,4 +1,7 @@
-use std::collections::{hash_map, BTreeSet, HashMap};
+use std::{
+    cmp::min,
+    collections::{hash_map, BTreeSet, HashMap},
+};
 
 use zksync_types::{
     l1::L1Tx, l2::L2Tx, Address, ExecuteTransactionCommon, Nonce, PriorityOpId, Transaction,
@@ -57,6 +60,7 @@ impl MempoolStore {
         transactions: Vec<Transaction>,
         initial_nonces: HashMap<Address, Nonce>,
     ) {
+        let mut min_next_priority_id = None;
         for transaction in transactions {
             let Transaction {
                 common_data,
@@ -66,7 +70,17 @@ impl MempoolStore {
             } = transaction;
             match common_data {
                 ExecuteTransactionCommon::L1(data) => {
-                    tracing::trace!("inserting L1 transaction {}", data.serial_id);
+                    tracing::info!(
+                        "inserting L1 transaction {}, current next_priority_id is {}",
+                        data.serial_id,
+                        self.next_priority_id
+                    );
+                    if min_next_priority_id.is_none() {
+                        min_next_priority_id = Some(data.serial_id);
+                    } else {
+                        min_next_priority_id =
+                            Some(min(min_next_priority_id.unwrap(), data.serial_id));
+                    }
                     self.l1_transactions.insert(
                         data.serial_id,
                         L1Tx {
@@ -93,6 +107,11 @@ impl MempoolStore {
                 }
             }
         }
+        if let Some(min_next_priority_id) = min_next_priority_id {
+            if self.next_priority_id == PriorityOpId(0) {
+                self.next_priority_id = min_next_priority_id;
+            }
+        }
     }
 
     fn insert_l2_transaction(

core/lib/snapshots_applier/src/lib.rs

@@ -310,7 +310,7 @@ impl SnapshotsApplierTask {
     /// Returns `Some(false)` if the recovery is not completed.
     pub async fn is_recovery_completed(
         conn: &mut Connection<'_, Core>,
-        client: &dyn SnapshotsApplierMainNodeClient,
+        client: &Option<Box<dyn SnapshotsApplierMainNodeClient>>,
     ) -> anyhow::Result<RecoveryCompletionStatus> {
         let Some(applied_snapshot_status) = conn
             .snapshot_recovery_dal()
@@ -325,21 +325,24 @@ impl SnapshotsApplierTask {
         }
         // Currently, migrating tokens is the last step of the recovery.
         // The number of tokens is not a part of the snapshot header, so we have to re-query the main node.
-        let added_tokens = conn
-            .tokens_web3_dal()
-            .get_all_tokens(Some(applied_snapshot_status.l2_block_number))
-            .await?
-            .len();
-        let tokens_on_main_node = client
-            .fetch_tokens(applied_snapshot_status.l2_block_number)
-            .await?
-            .len();
+        if let Some(client) = client {
+            let added_tokens = conn
+                .tokens_web3_dal()
+                .get_all_tokens(Some(applied_snapshot_status.l2_block_number))
+                .await?
+                .len();
+            let tokens_on_main_node = client
+                .fetch_tokens(applied_snapshot_status.l2_block_number)
+                .await?
+                .len();
 
-        match added_tokens.cmp(&tokens_on_main_node) {
-            Ordering::Less => Ok(RecoveryCompletionStatus::InProgress),
-            Ordering::Equal => Ok(RecoveryCompletionStatus::Completed),
-            Ordering::Greater => anyhow::bail!("DB contains more tokens than the main node"),
+            return match added_tokens.cmp(&tokens_on_main_node) {
+                Ordering::Less => Ok(RecoveryCompletionStatus::InProgress),
+                Ordering::Equal => Ok(RecoveryCompletionStatus::Completed),
+                Ordering::Greater => anyhow::bail!("DB contains more tokens than the main node"),
+            };
         }
+        Ok(RecoveryCompletionStatus::Completed)
     }
 
     /// Specifies the L1 batch to recover from. This setting is ignored if recovery is complete or resumed.

core/lib/snapshots_applier/src/tests/mod.rs

@@ -11,9 +11,7 @@ use tokio::sync::Barrier;
 use zksync_health_check::CheckHealth;
 use zksync_object_store::MockObjectStore;
 use zksync_types::{
-    api::{BlockDetails, L1BatchDetails},
-    block::L1BatchHeader,
-    get_code_key, L1BatchNumber, ProtocolVersion, ProtocolVersionId,
+    block::L1BatchHeader, get_code_key, L1BatchNumber, ProtocolVersion, ProtocolVersionId,
 };
 
 use self::utils::{
@@ -30,7 +28,8 @@ async fn is_recovery_completed(
     client: &MockMainNodeClient,
 ) -> RecoveryCompletionStatus {
     let mut connection = pool.connection().await.unwrap();
-    SnapshotsApplierTask::is_recovery_completed(&mut connection, client)
+    let client: Box<dyn SnapshotsApplierMainNodeClient> = Box::new(client.clone());
+    SnapshotsApplierTask::is_recovery_completed(&mut connection, &Some(client))
         .await
         .unwrap()
 }

core/lib/snapshots_applier/src/tests/utils.rs

@@ -11,7 +11,6 @@ use tokio::sync::watch;
 use zksync_object_store::{Bucket, MockObjectStore, ObjectStore, ObjectStoreError, StoredObject};
 use zksync_types::{
     api,
-    api::L1BatchDetails,
     block::L2BlockHeader,
     snapshots::{
         SnapshotFactoryDependencies, SnapshotFactoryDependency, SnapshotHeader,

core/lib/vm_executor/src/oneshot/block.rs

@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use anyhow::Context;
 use zksync_dal::{Connection, Core, CoreDal, DalError};
 use zksync_multivm::{
@@ -54,7 +56,9 @@ impl BlockInfo {
             .get_expected_l1_batch_timestamp(&l1_batch)
             .await
             .map_err(DalError::generalize)?
-            .context("missing timestamp for non-pending block")?;
+            .context(format!(
+                "missing timestamp for non-pending block {number}, l1_batch {l1_batch:?}"
+            ))?;
         Ok(Self {
             resolved_block_number: number,
             l1_batch_timestamp_s: Some(l1_batch_timestamp),
@@ -305,6 +309,14 @@ async fn load_l2_block_info(
             prev_block_hash = snapshot_recovery.and_then(|recovery| {
                 (recovery.l2_block_number == prev_block_number).then_some(recovery.l2_block_hash)
             });
+            if prev_block_hash.is_none() {
+                prev_block_hash = Some(
+                    H256::from_str(
+                        &"0x3259078d280da94b303592f6640e70c723c24018ab6d592a45931477e6645ab5",
+                    )
+                    .unwrap(),
+                );
+            }
         }
 
         current_block = Some(prev_l2_block);