Feat: Replace Class Hash issue resolved, gas fees bug resolved, cap removed for pending tick

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Next release
 
+- feat: block resource cap removed from the pending tick
+- fix: replace class hash issue resolved + gas fees issue resolved
 - fix(block_production): continue pending block now reexecutes the previous transactions
 - feat(services): reworked Madara services for better cancellation control
 - feat: fetch eth/strk price and sync strk gas price

crates/client/block_production/src/finalize_execution_state.rs

@@ -70,7 +70,10 @@ pub(crate) fn state_map_to_state_diff(
     let mut replaced_classes = Vec::new();
     for (contract_address, new_class_hash) in diff.class_hashes {
         let replaced = if let Some(on_top_of) = on_top_of {
-            backend.get_contract_class_hash_at(on_top_of, &contract_address.to_felt())?.is_some()
+            match backend.get_contract_class_hash_at(on_top_of, &contract_address.to_felt())? {
+                Some(class_hash) => class_hash != new_class_hash.to_felt(),
+                None => false,
+            }
         } else {
             // Executing genesis block: nothing being redefined here
             false

crates/client/block_production/src/lib.rs

@@ -18,7 +18,7 @@
 use crate::close_block::close_block;
 use crate::metrics::BlockProductionMetrics;
 use blockifier::blockifier::transaction_executor::{TransactionExecutor, BLOCK_STATE_ACCESS_ERR};
-use blockifier::bouncer::{BouncerWeights, BuiltinCount};
+use blockifier::bouncer::BouncerWeights;
 use blockifier::transaction::errors::TransactionExecutionError;
 use finalize_execution_state::StateDiffToStateMapError;
 use mc_block_import::{BlockImportError, BlockImporter};
@@ -77,6 +77,15 @@ pub enum Error {
     #[error("State diff error when continuing the pending block: {0:#}")]
     PendingStateDiff(#[from] StateDiffToStateMapError),
 }
+
+struct ContinueBlockResult {
+    state_diff: StateDiff,
+    visited_segments: VisitedSegments,
+    bouncer_weights: BouncerWeights,
+    stats: ContinueBlockStats,
+    block_now_full: bool,
+}
+
 /// The block production task consumes transactions from the mempool in batches.
 /// This is to allow optimistic concurrency. However, the block may get full during batch execution,
 /// and we need to re-add the transactions back into the mempool.
@@ -165,11 +174,9 @@ impl<Mempool: MempoolProvider> BlockProductionTask<Mempool> {
     }
 
     #[tracing::instrument(skip(self), fields(module = "BlockProductionTask"))]
-    fn continue_block(
-        &mut self,
-        bouncer_cap: BouncerWeights,
-    ) -> Result<(StateDiff, VisitedSegments, BouncerWeights, ContinueBlockStats), Error> {
+    fn continue_block(&mut self, bouncer_cap: BouncerWeights) -> Result<ContinueBlockResult, Error> {
         let mut stats = ContinueBlockStats::default();
+        let mut block_now_full = false;
 
         self.executor.bouncer.bouncer_config.block_max_capacity = bouncer_cap;
         let batch_size = self.backend.chain_config().execution_batch_size;
@@ -201,7 +208,7 @@ impl<Mempool: MempoolProvider> BlockProductionTask<Mempool> {
             // Execute the transactions.
             let all_results = self.executor.execute_txs(&txs_to_process_blockifier);
             // When the bouncer cap is reached, blockifier will return fewer results than what we asked for.
-            let block_now_full = all_results.len() < txs_to_process_blockifier.len();
+            block_now_full = all_results.len() < txs_to_process_blockifier.len();
 
             txs_to_process_blockifier.drain(..all_results.len()); // remove the used txs
 
@@ -273,54 +280,24 @@ impl<Mempool: MempoolProvider> BlockProductionTask<Mempool> {
             stats.n_re_added_to_mempool
         );
 
-        Ok((state_diff, visited_segments, bouncer_weights, stats))
+        Ok(ContinueBlockResult { state_diff, visited_segments, bouncer_weights, stats, block_now_full })
     }
 
     /// Each "tick" of the block time updates the pending block but only with the appropriate fraction of the total bouncer capacity.
     #[tracing::instrument(skip(self), fields(module = "BlockProductionTask"))]
-    pub fn on_pending_time_tick(&mut self) -> Result<(), Error> {
+    pub async fn on_pending_time_tick(&mut self) -> Result<(), Error> {
         let current_pending_tick = self.current_pending_tick;
-        let n_pending_ticks_per_block = self.backend.chain_config().n_pending_ticks_per_block();
-        let config_bouncer = self.backend.chain_config().bouncer_config.block_max_capacity;
         if current_pending_tick == 0 {
             return Ok(());
         }
 
-        // Reduced bouncer capacity for the current pending tick
-
-        // reduced_gas = gas * current_pending_tick/n_pending_ticks_per_block
-        // - we're dealing with integers here so prefer having the division last
-        // - use u128 here because the multiplication would overflow
-        // - div by zero: see [`ChainConfig::precheck_block_production`]
-        let reduced_cap =
-            |v: usize| (v as u128 * current_pending_tick as u128 / n_pending_ticks_per_block as u128) as usize;
-
-        let gas = reduced_cap(config_bouncer.gas);
-        let frac = current_pending_tick as f64 / n_pending_ticks_per_block as f64;
-        tracing::debug!("begin pending tick {current_pending_tick}/{n_pending_ticks_per_block}, proportion for this tick: {frac:.2}, gas limit: {gas}/{}", config_bouncer.gas);
-
-        let bouncer_cap = BouncerWeights {
-            builtin_count: BuiltinCount {
-                add_mod: reduced_cap(config_bouncer.builtin_count.add_mod),
-                bitwise: reduced_cap(config_bouncer.builtin_count.bitwise),
-                ecdsa: reduced_cap(config_bouncer.builtin_count.ecdsa),
-                ec_op: reduced_cap(config_bouncer.builtin_count.ec_op),
-                keccak: reduced_cap(config_bouncer.builtin_count.keccak),
-                mul_mod: reduced_cap(config_bouncer.builtin_count.mul_mod),
-                pedersen: reduced_cap(config_bouncer.builtin_count.pedersen),
-                poseidon: reduced_cap(config_bouncer.builtin_count.poseidon),
-                range_check: reduced_cap(config_bouncer.builtin_count.range_check),
-                range_check96: reduced_cap(config_bouncer.builtin_count.range_check96),
-            },
-            gas,
-            message_segment_length: reduced_cap(config_bouncer.message_segment_length),
-            n_events: reduced_cap(config_bouncer.n_events),
-            n_steps: reduced_cap(config_bouncer.n_steps),
-            state_diff_size: reduced_cap(config_bouncer.state_diff_size),
-        };
+        // Use full bouncer capacity
+        let bouncer_cap = self.backend.chain_config().bouncer_config.block_max_capacity;
 
         let start_time = Instant::now();
-        let (state_diff, visited_segments, bouncer_weights, stats) = self.continue_block(bouncer_cap)?;
+
+        let ContinueBlockResult { state_diff, visited_segments, bouncer_weights, stats, block_now_full } =
+            self.continue_block(bouncer_cap)?;
         if stats.n_added_to_block > 0 {
             tracing::info!(
                 "🧮 Executed and added {} transaction(s) to the pending block at height {} - {:?}",
@@ -330,6 +307,13 @@ impl<Mempool: MempoolProvider> BlockProductionTask<Mempool> {
             );
         }
 
+        // Check if block is full
+        if block_now_full {
+            tracing::info!("Resource limits reached, closing block early");
+            self.on_block_time().await?;
+            return Ok(());
+        }
+
         // Store pending block
         // todo, prefer using the block import pipeline?
         self.backend.store_block(
@@ -353,8 +337,13 @@ impl<Mempool: MempoolProvider> BlockProductionTask<Mempool> {
 
         // Complete the block with full bouncer capacity.
         let start_time = Instant::now();
-        let (mut new_state_diff, visited_segments, _weights, _stats) =
-            self.continue_block(self.backend.chain_config().bouncer_config.block_max_capacity)?;
+        let ContinueBlockResult {
+            state_diff: mut new_state_diff,
+            visited_segments,
+            bouncer_weights: _weights,
+            stats: _stats,
+            block_now_full: _block_now_full,
+        } = self.continue_block(self.backend.chain_config().bouncer_config.block_max_capacity)?;
 
         // SNOS requirement: For blocks >= 10, the hash of the block 10 blocks prior
         // at address 0x1 with the block number as the key
@@ -473,7 +462,7 @@ impl<Mempool: MempoolProvider> BlockProductionTask<Mempool> {
                         continue
                     }
 
-                    if let Err(err) = self.on_pending_time_tick() {
+                    if let Err(err) = self.on_pending_time_tick().await {
                         tracing::error!("Pending block update task has errored: {err:#}");
                     }
                     self.current_pending_tick += 1;

crates/client/devnet/src/lib.rs

@@ -385,8 +385,11 @@ mod tests {
 
         assert_eq!(res.class_hash, calculated_class_hash);
 
-        chain.block_production.set_current_pending_tick(1);
-        chain.block_production.on_pending_time_tick().unwrap();
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            chain.block_production.set_current_pending_tick(1);
+            chain.block_production.on_pending_time_tick().await.unwrap();
+        });
 
         let block = chain.backend.get_block(&BlockId::Tag(BlockTag::Pending)).unwrap().unwrap();
 
@@ -454,8 +457,11 @@ mod tests {
             .unwrap();
         tracing::debug!("tx hash: {:#x}", transfer_txn.transaction_hash);
 
-        chain.block_production.set_current_pending_tick(chain.backend.chain_config().n_pending_ticks_per_block());
-        chain.block_production.on_pending_time_tick().unwrap();
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            chain.block_production.set_current_pending_tick(chain.backend.chain_config().n_pending_ticks_per_block());
+            chain.block_production.on_pending_time_tick().await.unwrap();
+        });
 
         // =====================================================================================
 
@@ -486,8 +492,11 @@ mod tests {
 
         let res = chain.sign_and_add_deploy_account_tx(deploy_account_txn, &account).unwrap();
 
-        chain.block_production.set_current_pending_tick(chain.backend.chain_config().n_pending_ticks_per_block());
-        chain.block_production.on_pending_time_tick().unwrap();
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            chain.block_production.set_current_pending_tick(chain.backend.chain_config().n_pending_ticks_per_block());
+            chain.block_production.on_pending_time_tick().await.unwrap();
+        });
 
         assert_eq!(res.contract_address, account.address);
 
@@ -547,8 +556,11 @@ mod tests {
 
         tracing::info!("tx hash: {:#x}", result.transaction_hash);
 
-        chain.block_production.set_current_pending_tick(1);
-        chain.block_production.on_pending_time_tick().unwrap();
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            chain.block_production.set_current_pending_tick(1);
+            chain.block_production.on_pending_time_tick().await.unwrap();
+        });
 
         let block = chain.backend.get_block(&BlockId::Tag(BlockTag::Pending)).unwrap().unwrap();
 
@@ -753,8 +765,11 @@ mod tests {
             .unwrap();
 
         std::thread::sleep(max_age); // max age reached
-        chain.block_production.set_current_pending_tick(1);
-        chain.block_production.on_pending_time_tick().unwrap();
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        rt.block_on(async {
+            chain.block_production.set_current_pending_tick(1);
+            chain.block_production.on_pending_time_tick().await.unwrap();
+        });
 
         let block = chain.backend.get_block(&BlockId::Tag(BlockTag::Pending)).unwrap().unwrap();
 

crates/client/eth/src/client.rs

@@ -181,7 +181,7 @@ pub mod eth_client_getter_test {
     const L2_STATE_ROOT: &str = "1456190284387746219409791261254265303744585499659352223397867295223408682130";
 
     lazy_static::lazy_static! {
-        static ref FORK_URL: String = std::env::var("ETH_FORK_URL").expect("ETH_FORK_URL not set");
+        static ref FORK_URL: String = std::env::var("ETH_FORK_URL").unwrap_or("https://eth-mainnet.g.alchemy.com/v2/svwTUdkIFaUU8uh3Uutn-0-UzsM9ee6q".to_string());
     }
 
     const PORT_RANGE: Range<u16> = 19500..20000;

crates/client/mempool/src/l1.rs

@@ -7,8 +7,14 @@ use std::time::SystemTime;
 
 #[derive(Clone)]
 pub struct GasPriceProvider {
+    /// Gas prices protected by a mutex
     gas_prices: Arc<Mutex<GasPrices>>,
     last_update: Arc<Mutex<SystemTime>>,
+    /// Using Relaxed ordering for atomic operations since:
+    /// 1. Gas prices are updated frequently (every few ms)
+    /// 2. Slight inconsistencies in gas price visibility between threads are acceptable
+    /// 3. Operations are independent and don't require synchronization with other memory operations
+    /// 4. Provides minimal performance overhead compared to stricter ordering options
     gas_price_sync_enabled: Arc<AtomicBool>,
     data_gas_price_sync_enabled: Arc<AtomicBool>,
     strk_gas_price_sync_enabled: Arc<AtomicBool>,