lint

Thegaram · Thegaram · commit 1f7f296623dd · 2025-11-05T11:34:13.000+01:00
diff --git a/crates/scroll/alloy/evm/src/block/mod.rs b/crates/scroll/alloy/evm/src/block/mod.rs
@@ -123,7 +123,8 @@ where
     {
         self.apply_pre_execution_changes()?;
 
-        for (tx, (compression_ratio, compressed_size)) in transactions.into_iter().zip(compression_infos.into_iter())
+        for (tx, (compression_ratio, compressed_size)) in
+            transactions.into_iter().zip(compression_infos.into_iter())
         {
             let tx = tx.with_compression_info(compression_ratio, compressed_size);
             self.execute_transaction(&tx)?;
diff --git a/crates/scroll/alloy/evm/src/lib.rs b/crates/scroll/alloy/evm/src/lib.rs
@@ -12,8 +12,8 @@ pub use block::{
 
 mod tx;
 pub use tx::{
-    compute_compression_ratio, compute_compressed_size, FromTxWithCompressionInfo, ScrollTransactionIntoTxEnv,
-    ToTxWithCompressionInfo, WithCompressionInfo,
+    compute_compressed_size, compute_compression_ratio, FromTxWithCompressionInfo,
+    ScrollTransactionIntoTxEnv, ToTxWithCompressionInfo, WithCompressionInfo,
 };
 
 mod system_caller;
diff --git a/crates/scroll/alloy/evm/src/tx/compression.rs b/crates/scroll/alloy/evm/src/tx/compression.rs
@@ -6,7 +6,7 @@ use alloy_evm::{RecoveredTx, ToTxEnv};
 use alloy_primitives::{Address, Bytes, TxKind, U256};
 use revm::context::TxEnv;
 use scroll_alloy_consensus::{ScrollTxEnvelope, TxL1Message};
-pub use zstd_compression::{compute_compression_ratio, compute_compressed_size};
+pub use zstd_compression::{compute_compressed_size, compute_compression_ratio};
 
 #[cfg(feature = "zstd_compression")]
 mod zstd_compression {
@@ -41,7 +41,11 @@ mod zstd_compression {
         let result = compressor.finish().expect("failed to finish compression");
         let encoded_bytes_len = result.len();
 
-        if encoded_bytes_len > original_bytes_len { original_bytes_len } else { encoded_bytes_len }
+        if encoded_bytes_len > original_bytes_len {
+            original_bytes_len
+        } else {
+            encoded_bytes_len
+        }
     }
 
     /// Computes the compression ratio for the provided bytes.
@@ -127,13 +131,17 @@ where
         compression_ratio: Option<U256>,
         compressed_size: Option<usize>,
     ) -> Self {
-        TxEnv::from_tx_with_compression_info(tx, sender, encoded, compression_ratio, compressed_size)
+        TxEnv::from_tx_with_compression_info(
+            tx,
+            sender,
+            encoded,
+            compression_ratio,
+            compressed_size,
+        )
     }
 }
 
-impl<T, TxEnv: FromTxWithCompressionInfo<T>> ToTxEnv<TxEnv>
-    for WithCompressionInfo<Recovered<T>>
-{
+impl<T, TxEnv: FromTxWithCompressionInfo<T>> ToTxEnv<TxEnv> for WithCompressionInfo<Recovered<T>> {
     fn to_tx_env(&self) -> TxEnv {
         let recovered = &self.value;
         TxEnv::from_tx_with_compression_info(
@@ -146,9 +154,7 @@ impl<T, TxEnv: FromTxWithCompressionInfo<T>> ToTxEnv<TxEnv>
     }
 }
 
-impl<T, TxEnv: FromTxWithCompressionInfo<T>> ToTxEnv<TxEnv>
-    for WithCompressionInfo<&Recovered<T>>
-{
+impl<T, TxEnv: FromTxWithCompressionInfo<T>> ToTxEnv<TxEnv> for WithCompressionInfo<&Recovered<T>> {
     fn to_tx_env(&self) -> TxEnv {
         let recovered = &self.value;
         TxEnv::from_tx_with_compression_info(
@@ -241,7 +247,7 @@ mod tests {
     use crate::compute_compressed_size;
 
     use super::compute_compression_ratio;
-    use alloy_primitives::{bytes, U256, uint};
+    use alloy_primitives::{bytes, uint, U256};
 
     #[test]
     fn test_compute_compression_ratio() -> eyre::Result<()> {
@@ -286,7 +292,8 @@ mod tests {
 
         // etherfi-stargate
         // https://scrollscan.com/tx/0x08bf18e860d4770920ba838fe709ca202227aa9afea1b0c11314e7f41fc5f578
-        let bytes = bytes!("0x5988e7a1000000000000000000000000388325dd7c76e37cfda1ed6d8a97849a46b5512a");
+        let bytes =
+            bytes!("0x5988e7a1000000000000000000000000388325dd7c76e37cfda1ed6d8a97849a46b5512a");
         let ratio = compute_compression_ratio(&bytes);
         let size = compute_compressed_size(&bytes);
         assert_eq!(ratio, U256::from(1_000_000_000)); // 1x
diff --git a/crates/scroll/alloy/evm/src/tx/mod.rs b/crates/scroll/alloy/evm/src/tx/mod.rs
@@ -13,8 +13,8 @@ use scroll_alloy_consensus::{ScrollTxEnvelope, TxL1Message, L1_MESSAGE_TRANSACTI
 
 mod compression;
 pub use compression::{
-    compute_compression_ratio, compute_compressed_size, FromTxWithCompressionInfo, ToTxWithCompressionInfo,
-    WithCompressionInfo,
+    compute_compressed_size, compute_compression_ratio, FromTxWithCompressionInfo,
+    ToTxWithCompressionInfo, WithCompressionInfo,
 };
 
 /// This structure wraps around a [`ScrollTransaction`] and allows us to implement the [`IntoTxEnv`]
@@ -27,7 +27,12 @@ pub struct ScrollTransactionIntoTxEnv<T: Transaction>(ScrollTransaction<T>);
 
 impl<T: Transaction> ScrollTransactionIntoTxEnv<T> {
     /// Returns a new [`ScrollTransactionIntoTxEnv`].
-    pub fn new(base: T, rlp_bytes: Option<Bytes>, compression_ratio: Option<U256>, compressed_size: Option<usize>) -> Self {
+    pub fn new(
+        base: T,
+        rlp_bytes: Option<Bytes>,
+        compression_ratio: Option<U256>,
+        compressed_size: Option<usize>,
+    ) -> Self {
         Self(ScrollTransaction::new(base, rlp_bytes, compression_ratio, compressed_size))
     }
 }
diff --git a/crates/scroll/evm/src/execute.rs b/crates/scroll/evm/src/execute.rs
@@ -49,7 +49,8 @@ mod tests {
         Block, BlockBody, Header, SignableTransaction, Signed, Transaction, TxLegacy,
     };
     use alloy_eips::{
-        Encodable2718, Typed2718, eip7702::{Authorization, SignedAuthorization, constants::PER_EMPTY_ACCOUNT_COST}
+        eip7702::{constants::PER_EMPTY_ACCOUNT_COST, Authorization, SignedAuthorization},
+        Encodable2718, Typed2718,
     };
     use alloy_evm::{
         block::{BlockExecutionResult, BlockExecutor},
@@ -76,8 +77,7 @@ mod tests {
     };
     use scroll_alloy_consensus::{ScrollTransactionReceipt, ScrollTxEnvelope, ScrollTxType};
     use scroll_alloy_evm::{
-        compute_compression_ratio,
-        compute_compressed_size,
+        compute_compressed_size, compute_compression_ratio,
         curie::{
             BLOB_SCALAR_SLOT, COMMIT_SCALAR_SLOT, CURIE_L1_GAS_PRICE_ORACLE_BYTECODE,
             CURIE_L1_GAS_PRICE_ORACLE_STORAGE, IS_CURIE_SLOT, L1_BLOB_BASE_FEE_SLOT,
@@ -222,7 +222,8 @@ mod tests {
         transactions: Vec<ScrollTxEnvelope>,
         block_number: u64,
         block_timestamp: u64,
-        compression_infos: Option<Vec<(U256, usize)>>, // (compression ratio, compressed size) pairs
+        compression_infos: Option<Vec<(U256, usize)>>, /* (compression ratio, compressed size)
+                                                        * pairs */
     ) -> eyre::Result<BlockExecutionResult<ScrollReceipt>> {
         let block = block(block_number, block_timestamp, transactions);
 
@@ -654,8 +655,12 @@ mod tests {
             transaction(ScrollTxType::Eip1559, MIN_TRANSACTION_GAS),
             transaction(ScrollTxType::Eip7702, MIN_TRANSACTION_GAS),
         ];
-        let compression_infos =
-            transactions.iter().map(|tx| (compute_compression_ratio(tx.input()), compute_compressed_size(&tx.encoded_2718()))).collect::<Vec<_>>();
+        let compression_infos = transactions
+            .iter()
+            .map(|tx| {
+                (compute_compression_ratio(tx.input()), compute_compressed_size(&tx.encoded_2718()))
+            })
+            .collect::<Vec<_>>();
         let with_compression_infos = execute_block(
             transactions.clone(),
             CURIE_BLOCK_NUMBER + 1,
diff --git a/crates/scroll/evm/src/l1.rs b/crates/scroll/evm/src/l1.rs
@@ -14,15 +14,16 @@ pub trait RethL1BlockInfo {
     /// - `timestamp`: The timestamp of the current block.
     /// - `block`: The block number of the current block.
     /// - `input`: The calldata of the transaction.
+    /// - `compression_info`: An optional tuple containing the compression ratio and compressed
+    ///   size.
     /// - `is_l1_message`: Whether or not the transaction is a l1 message.
     fn l1_tx_data_fee(
         &mut self,
         chain_spec: impl ScrollHardforks,
         timestamp: u64,
         block: u64,
         input: &[u8],
-        compression_ratio: Option<U256>,
-        compressed_size: Option<usize>,
+        compression_info: Option<(U256, usize)>,
         is_l1_message: bool,
     ) -> Result<U256, BlockExecutionError>;
 }
@@ -34,14 +35,18 @@ impl RethL1BlockInfo for L1BlockInfo {
         timestamp: u64,
         block_number: u64,
         input: &[u8],
-        compression_ratio: Option<U256>,
-        compressed_size: Option<usize>,
+        compression_info: Option<(U256, usize)>,
         is_l1_message: bool,
     ) -> Result<U256, BlockExecutionError> {
         if is_l1_message {
             return Ok(U256::ZERO);
         }
 
+        let (compression_ratio, compressed_size) = match compression_info {
+            Some((ratio, size)) => (Some(ratio), Some(size)),
+            None => (None, None),
+        };
+
         let spec_id = spec_id_at_timestamp_and_number(timestamp, block_number, chain_spec);
         Ok(self.calculate_tx_l1_cost(input, spec_id, compression_ratio, compressed_size))
     }
diff --git a/crates/scroll/evm/src/lib.rs b/crates/scroll/evm/src/lib.rs
@@ -35,8 +35,8 @@ use reth_scroll_chainspec::ScrollChainSpec;
 use reth_scroll_primitives::ScrollPrimitives;
 use revm_scroll::ScrollSpecId;
 pub use scroll_alloy_evm::{
-    compute_compression_ratio, compute_compressed_size, ScrollBlockExecutorFactory, ScrollDefaultPrecompilesFactory,
-    ScrollEvmFactory, ScrollTxCompressionInfos,
+    compute_compressed_size, compute_compression_ratio, ScrollBlockExecutorFactory,
+    ScrollDefaultPrecompilesFactory, ScrollEvmFactory, ScrollTxCompressionInfos,
 };
 pub use scroll_alloy_hardforks::{ScrollHardfork, ScrollHardforks};
 
diff --git a/crates/scroll/txpool/src/validator.rs b/crates/scroll/txpool/src/validator.rs
@@ -8,7 +8,8 @@ use reth_primitives_traits::{
 use reth_revm::database::StateProviderDatabase;
 use reth_scroll_consensus::MAX_ROLLUP_FEE;
 use reth_scroll_evm::{
-    compute_compression_ratio, compute_compressed_size, spec_id_at_timestamp_and_number, RethL1BlockInfo,
+    compute_compressed_size, compute_compression_ratio, spec_id_at_timestamp_and_number,
+    RethL1BlockInfo,
 };
 use reth_scroll_forks::ScrollHardforks;
 use reth_storage_api::{BlockReaderIdExt, StateProviderFactory};
@@ -188,8 +189,7 @@ where
                 self.block_timestamp(),
                 self.block_number(),
                 &encoded,
-                Some(compression_ratio),
-                Some(compressed_size),
+                Some((compression_ratio, compressed_size)),
                 false,
             ) {
                 Ok(cost) => cost,

Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,8 @@ where`
`123`	`123`	`{`
`124`	`124`	`self.apply_pre_execution_changes()?;`
`125`	`125`
`126`		`- for (tx, (compression_ratio, compressed_size)) in transactions.into_iter().zip(compression_infos.into_iter())`
	`126`	`+ for (tx, (compression_ratio, compressed_size)) in`
	`127`	`+ transactions.into_iter().zip(compression_infos.into_iter())`
`127`	`128`	`{`
`128`	`129`	`let tx = tx.with_compression_info(compression_ratio, compressed_size);`
`129`	`130`	`self.execute_transaction(&tx)?;`