feat: Allow tracking l2 fees for L2-based chains

core/bin/external_node/src/node_builder.rs

@@ -169,6 +169,8 @@ impl ExternalNodeBuilder {
         let query_eth_client_layer = QueryEthClientLayer::new(
             self.config.required.settlement_layer_id(),
             self.config.required.eth_client_url.clone(),
+            // TODO(EVM-676): add this config for external node
+            false,
         );
         self.node.add_layer(query_eth_client_layer);
         Ok(self)

core/bin/external_node/src/tests/framework.rs

@@ -127,7 +127,9 @@ impl WiringLayer for MockL1ClientLayer {
 
     fn layer_name(&self) -> &'static str {
         // We don't care about values, we just want to hijack the layer name.
-        QueryEthClientLayer::new(SLChainId(1), "https://example.com".parse().unwrap()).layer_name()
+        // TODO(EVM-676): configure the `l2_mode` here
+        QueryEthClientLayer::new(SLChainId(1), "https://example.com".parse().unwrap(), false)
+            .layer_name()
     }
 
     async fn wire(self, _: Self::Input) -> Result<Self::Output, WiringError> {

core/bin/external_node/src/tests/utils.rs

@@ -1,7 +1,7 @@
 use tempfile::TempDir;
 use zksync_dal::CoreDal;
 use zksync_db_connection::connection_pool::TestTemplate;
-use zksync_eth_client::clients::MockEthereum;
+use zksync_eth_client::clients::MockSettlementLayer;
 use zksync_node_genesis::{insert_genesis_batch, GenesisBatchParams, GenesisParams};
 use zksync_types::{
     api, block::L2BlockHeader, ethabi, Address, L2BlockNumber, ProtocolVersionId, H256,
@@ -119,7 +119,7 @@ pub(super) fn expected_health_components(components: &ComponentsToRun) -> Vec<&'
 }
 
 pub(super) fn mock_eth_client(diamond_proxy_addr: Address) -> MockClient<L1> {
-    let mock = MockEthereum::builder().with_call_handler(move |call, _| {
+    let mock = MockSettlementLayer::builder().with_call_handler(move |call, _| {
         tracing::info!("L1 call: {call:?}");
         if call.to == Some(diamond_proxy_addr) {
             let packed_semver = ProtocolVersionId::latest().into_packed_semver_with_patch(0);

core/bin/zksync_server/src/node_builder.rs

@@ -151,8 +151,16 @@ impl MainNodeBuilder {
     fn add_query_eth_client_layer(mut self) -> anyhow::Result<Self> {
         let genesis = self.genesis_config.clone();
         let eth_config = try_load_config!(self.secrets.l1);
-        let query_eth_client_layer =
-            QueryEthClientLayer::new(genesis.settlement_layer_id(), eth_config.l1_rpc_url);
+        let query_eth_client_layer = QueryEthClientLayer::new(
+            genesis.settlement_layer_id(),
+            eth_config.l1_rpc_url,
+            self.configs
+                .eth
+                .as_ref()
+                .and_then(|x| x.gas_adjuster)
+                .and_then(|x| x.l2_mode)
+                .unwrap_or_default(),
+        );
         self.node.add_layer(query_eth_client_layer);
         Ok(self)
     }

core/lib/basic_types/src/lib.rs

@@ -89,7 +89,7 @@ impl TryFrom<U256> for AccountTreeId {
 
 /// ChainId in the ZKsync network.
 #[derive(Copy, Clone, Debug, Serialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct L2ChainId(u64);
+pub struct L2ChainId(pub u64);
 
 impl<'de> Deserialize<'de> for L2ChainId {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

core/lib/config/src/configs/eth_sender.rs

@@ -54,6 +54,7 @@ impl EthConfig {
                 num_samples_for_blob_base_fee_estimate: 10,
                 internal_pubdata_pricing_multiplier: 1.0,
                 max_blob_base_fee: None,
+                l2_mode: None,
             }),
             watcher: Some(EthWatchConfig {
                 confirmations_for_eth_event: None,
@@ -82,6 +83,7 @@ pub enum PubdataSendingMode {
     Calldata,
     Blobs,
     Custom,
+    RelayedL2Calldata,
 }
 
 #[derive(Debug, Deserialize, Clone, PartialEq)]
@@ -181,6 +183,9 @@ pub struct GasAdjusterConfig {
     pub internal_pubdata_pricing_multiplier: f64,
     /// Max blob base fee that is allowed to be used.
     pub max_blob_base_fee: Option<u64>,
+    /// Whether the gas adjuster should require that the L2 node is used as a settlement layer.
+    /// It offers a runtime check for correctly provided values.
+    pub l2_mode: Option<bool>,
 }
 
 impl GasAdjusterConfig {

core/lib/config/src/testonly.rs

@@ -397,6 +397,8 @@ impl Distribution<configs::eth_sender::GasAdjusterConfig> for EncodeDist {
             num_samples_for_blob_base_fee_estimate: self.sample(rng),
             internal_pubdata_pricing_multiplier: self.sample(rng),
             max_blob_base_fee: self.sample(rng),
+            // TODO(EVM-676): generate it randomly once this value is used
+            l2_mode: None,
         }
     }
 }

core/lib/dal/src/blocks_web3_dal.rs

@@ -5,6 +5,7 @@ use zksync_db_connection::{
 use zksync_system_constants::EMPTY_UNCLES_HASH;
 use zksync_types::{
     api,
+    fee_model::BatchFeeInput,
     l2_to_l1_log::L2ToL1Log,
     vm_trace::Call,
     web3::{BlockHeader, Bytes},
@@ -564,17 +565,21 @@ impl BlocksWeb3Dal<'_, '_> {
         .collect())
     }
 
-    /// Returns `base_fee_per_gas` for L2 block range [min(newest_block - block_count + 1, 0), newest_block]
+    /// Returns `base_fee_per_gas` and `fair_pubdata_price` for L2 block range [min(newest_block - block_count + 1, 0), newest_block]
     /// in descending order of L2 block numbers.
     pub async fn get_fee_history(
         &mut self,
         newest_block: L2BlockNumber,
         block_count: u64,
-    ) -> DalResult<Vec<U256>> {
+    ) -> DalResult<(Vec<U256>, Vec<U256>)> {
         let result: Vec<_> = sqlx::query!(
             r#"
             SELECT
-                base_fee_per_gas
+                base_fee_per_gas,
+                l2_fair_gas_price,
+                fair_pubdata_price,
+                protocol_version,
+                l1_gas_price
             FROM
                 miniblocks
             WHERE
@@ -593,10 +598,27 @@ impl BlocksWeb3Dal<'_, '_> {
         .fetch_all(self.storage)
         .await?
         .into_iter()
-        .map(|row| bigdecimal_to_u256(row.base_fee_per_gas))
+        .map(|row| {
+            let fee_input = BatchFeeInput::for_protocol_version(
+                row.protocol_version
+                    .map(|x| (x as u16).try_into().unwrap())
+                    .unwrap_or_else(ProtocolVersionId::last_potentially_undefined),
+                row.l2_fair_gas_price as u64,
+                row.fair_pubdata_price.map(|x| x as u64),
+                row.l1_gas_price as u64,
+            );
+
+            (
+                bigdecimal_to_u256(row.base_fee_per_gas),
+                U256::from(fee_input.fair_pubdata_price()),
+            )
+        })
         .collect();
 
-        Ok(result)
+        let (base_fee_per_gas, effective_pubdata_price): (Vec<U256>, Vec<U256>) =
+            result.into_iter().unzip();
+
+        Ok((base_fee_per_gas, effective_pubdata_price))
     }
 
     pub async fn get_block_details(

core/lib/env_config/src/eth_sender.rs

@@ -84,6 +84,7 @@ mod tests {
                     num_samples_for_blob_base_fee_estimate: 10,
                     internal_pubdata_pricing_multiplier: 1.0,
                     max_blob_base_fee: None,
+                    l2_mode: None,
                 }),
                 watcher: Some(EthWatchConfig {
                     confirmations_for_eth_event: Some(0),

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

@@ -1,9 +1,9 @@
 use jsonrpsee::proc_macros::rpc;
 use zksync_types::{web3, Address, H256, U256, U64};
-use zksync_web3_decl::client::{ForNetwork, L1};
+use zksync_web3_decl::client::{ForEthereumLikeNetwork, L2};
 
 /// Subset of the L1 `eth` namespace used by the L1 client.
-#[rpc(client, namespace = "eth", client_bounds(Self: ForNetwork<Net = L1>))]
+#[rpc(client, namespace = "eth", client_bounds(Self: ForEthereumLikeNetwork))]
 pub(super) trait L1EthNamespace {
     #[method(name = "chainId")]
     async fn chain_id(&self) -> RpcResult<U256>;
@@ -66,3 +66,16 @@ pub(super) trait L1EthNamespace {
         hash: H256,
     ) -> RpcResult<Option<web3::TransactionReceipt>>;
 }
+
+/// Subset of the L2 `eth` namespace used by an L2 client. It may have the same
+/// methods as the L1 `eth` namespace, but with extended return values.
+#[rpc(client, namespace = "eth", client_bounds(Self: ForEthereumLikeNetwork<Net = L2>))]
+pub(super) trait L2EthNamespace {
+    #[method(name = "feeHistory")]
+    async fn fee_history(
+        &self,
+        block_count: U64,
+        newest_block: web3::BlockNumber,
+        reward_percentiles: Option<Vec<f32>>,
+    ) -> RpcResult<zksync_types::api::FeeHistory>;
+}

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

@@ -32,6 +32,7 @@ enum Method {
     #[metrics(name = "sign_prepared_tx_for_addr")]
     SignPreparedTx,
     Allowance,
+    L2FeeHistory,
 }
 
 #[derive(Debug, Metrics)]