update feynman compression

Author: frisitano

Cargo.lock

@@ -476,7 +476,7 @@ revm-context = { git = "https://github.com/scroll-tech/revm", branch = "feat/ret
 revm-context-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74", default-features = false }
 revm-database-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74", default-features = false }
 op-revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v74", default-features = false }
-revm-scroll = { path = "../scroll-revm", default-features = false }
+revm-scroll = { git = "https://github.com/scroll-tech/scroll-revm", branch = "feat/feynman-compression", default-features = false }
 revm-inspectors = "0.23.0"
 
 # eth

Cargo.toml

@@ -31,6 +31,7 @@ scroll-alloy-hardforks = { workspace = true, default-features = false }
 # misc
 auto_impl = { workspace = true, default-features = false }
 serde = { workspace = true, default-features = false, features = ["derive"], optional = true }
+zstd = { version = "0.13", features = ["experimental"] }
 
 [dev-dependencies]
 alloy-hardforks.workspace = true

crates/scroll/alloy/evm/Cargo.toml

@@ -6,8 +6,7 @@ mod receipt_builder;
 use crate::{
     block::curie::{apply_curie_hard_fork, L1_GAS_PRICE_ORACLE_ADDRESS},
     system_caller::ScrollSystemCaller,
-    IntoCompressed, ScrollEvm, ScrollEvmFactory, ScrollTransactionIntoTxEnv,
-    ScrollTxCompressionFactorCache, WithCompression,
+    FromTxWithCompression, IntoCompressed, ScrollEvm, ScrollEvmFactory, ScrollTransactionIntoTxEnv,
 };
 use alloc::{boxed::Box, format, vec::Vec};
 
@@ -18,7 +17,7 @@ use alloy_evm::{
         BlockExecutionError, BlockExecutionResult, BlockExecutor, BlockExecutorFactory,
         BlockExecutorFor, BlockValidationError, CommitChanges, ExecutableTx, OnStateHook,
     },
-    Database, Evm, EvmFactory, FromRecoveredTx, FromTxWithEncoded, IntoTxEnv, RecoveredTx,
+    Database, Evm, EvmFactory, FromRecoveredTx, FromTxWithEncoded,
 };
 use alloy_primitives::{B256, U256};
 use revm::{
@@ -35,6 +34,10 @@ use revm_scroll::builder::ScrollContext;
 use scroll_alloy_consensus::L1_MESSAGE_TRANSACTION_TYPE;
 use scroll_alloy_hardforks::{ScrollHardfork, ScrollHardforks};
 
+/// A cache for transaction compression factors, mapping transaction hashes to their compression
+/// factors.
+pub type ScrollTxCompressionFactors = Vec<U256>;
+
 /// Context for Scroll Block Execution.
 #[derive(Debug, Default, Clone)]
 pub struct ScrollBlockExecutionCtx {
@@ -93,68 +96,31 @@ where
     DB: Database + 'db,
     E: EvmExt<
         DB = &'db mut State<DB>,
-        Tx: FromRecoveredTx<R::Transaction> + FromTxWithEncoded<R::Transaction>,
-    >,
-    R: ScrollReceiptBuilder<
-        Transaction: Transaction + Encodable2718 + RecoveredTx<R::Transaction>,
-        Receipt: TxReceipt,
-    >,
-    Spec: ScrollHardforks,
-    for<'a> &'a WithCompression<<R as ScrollReceiptBuilder>::Transaction>:
-        IntoTxEnv<<E as alloy_evm::Evm>::Tx>,
-{
-    /// Executes all transactions in a block, applying pre and post execution changes.
-    pub fn execute_block_with_compression_cache(
-        mut self,
-        transactions: impl IntoIterator<
-            Item = impl ExecutableTx<Self> + IntoCompressed<<Self as BlockExecutor>::Transaction>,
-        >,
-        mut compression_cache: ScrollTxCompressionFactorCache,
-    ) -> Result<BlockExecutionResult<R::Receipt>, BlockExecutionError>
-    where
-        Self: Sized,
-    {
-        self.apply_pre_execution_changes()?;
-
-        for tx in transactions {
-            let tx = tx.into_compressed(Some(&mut compression_cache));
-            self.execute_transaction(&tx)?;
-        }
-
-        self.apply_post_execution_changes()
-    }
-}
-
-impl<'db, DB, E, R, Spec> ScrollBlockExecutor<E, R, Spec>
-where
-    DB: Database + 'db,
-    E: EvmExt<
-        DB = &'db mut State<DB>,
-        Tx: FromRecoveredTx<R::Transaction> + FromTxWithEncoded<R::Transaction>,
-    >,
-    R: ScrollReceiptBuilder<
-        Transaction: Transaction + Encodable2718 + RecoveredTx<R::Transaction>,
-        Receipt: TxReceipt,
+        Tx: FromRecoveredTx<R::Transaction>
+                + FromTxWithEncoded<R::Transaction>
+                + FromTxWithCompression<R::Transaction>,
     >,
+    R: ScrollReceiptBuilder<Transaction: Transaction + Encodable2718, Receipt: TxReceipt>,
     Spec: ScrollHardforks,
-    for<'a> &'a WithCompression<<R as ScrollReceiptBuilder>::Transaction>:
-        IntoTxEnv<<E as alloy_evm::Evm>::Tx>,
 {
-    /// Executes all transactions in a block, applying pre and post execution changes.
+    /// Executes all transactions in a block, applying pre and post execution changes. The provided
+    /// transaction compression factors are expected to be in the same order as the
+    /// transactions.
     pub fn execute_block_with_compression_cache(
         mut self,
         transactions: impl IntoIterator<
             Item = impl ExecutableTx<Self> + IntoCompressed<<Self as BlockExecutor>::Transaction>,
         >,
-        mut compression_cache: ScrollTxCompressionFactorCache,
+        compression_cache: ScrollTxCompressionFactors,
     ) -> Result<BlockExecutionResult<R::Receipt>, BlockExecutionError>
     where
         Self: Sized,
     {
         self.apply_pre_execution_changes()?;
 
-        for tx in transactions {
-            let tx = tx.into_compressed(Some(&mut compression_cache));
+        for (tx, compression_factor) in transactions.into_iter().zip(compression_cache.into_iter())
+        {
+            let tx = tx.into_compressed(compression_factor);
             self.execute_transaction(&tx)?;
         }
 

crates/scroll/alloy/evm/src/block/mod.rs

@@ -7,13 +7,13 @@
 mod block;
 pub use block::{
     curie, EvmExt, ReceiptBuilderCtx, ScrollBlockExecutionCtx, ScrollBlockExecutor,
-    ScrollBlockExecutorFactory, ScrollReceiptBuilder,
+    ScrollBlockExecutorFactory, ScrollReceiptBuilder, ScrollTxCompressionFactors,
 };
 
 mod tx;
 pub use tx::{
     compute_compression_factor, FromTxWithCompression, IntoCompressed, ScrollTransactionIntoTxEnv,
-    ScrollTxCompressionFactorCache, WithCompression,
+    WithCompression,
 };
 
 mod system_caller;
@@ -38,6 +38,7 @@ use revm::{
 use revm_scroll::{
     builder::{DefaultScrollContext, MaybeWithEip7702, ScrollBuilder, ScrollContext},
     instructions::ScrollInstructions,
+    l1block::TX_L1_FEE_PRECISION_U256,
     precompile::ScrollPrecompileProvider,
     ScrollSpecId, ScrollTransaction,
 };
@@ -149,7 +150,7 @@ where
             },
             rlp_bytes: Some(Default::default()),
             // TODO: What makes sense in the context of a system call?
-            compression_factor: Some(U256::ONE),
+            compression_factor: Some(TX_L1_FEE_PRECISION_U256),
         };
 
         let mut gas_limit = tx.base.gas_limit;

crates/scroll/alloy/evm/src/lib.rs

@@ -1,25 +1,63 @@
-use std::collections::HashMap;
+use std::io::Write;
 
-use alloy_consensus::transaction::Recovered;
-use alloy_eips::Typed2718;
-use alloy_evm::{IntoTxEnv, RecoveredTx};
-// use alloy_consensus::transaction::Recovered;
-// use alloy_evm::IntoTxEnv;
 use super::FromRecoveredTx;
 use crate::ScrollTransactionIntoTxEnv;
-use alloy_primitives::{Address, Bytes, TxKind, B256, U256};
+use alloy_consensus::transaction::Recovered;
+use alloy_eips::{Encodable2718, Typed2718};
+use alloy_evm::{IntoTxEnv, RecoveredTx};
+use alloy_primitives::{Address, Bytes, TxKind, U256};
 use revm::context::TxEnv;
+use revm_scroll::l1block::TX_L1_FEE_PRECISION;
 use scroll_alloy_consensus::{ScrollTxEnvelope, TxL1Message};
-
-/// A cache for transaction compression factors, mapping transaction hashes to their compression
-/// factors.
-pub type ScrollTxCompressionFactorCache = HashMap<B256, U256>;
-
-const TX_L1_FEE_PRECISION: U256 = U256::from_limbs([1_000_000_000u64, 0, 0, 0]);
+use zstd::{
+    stream::Encoder,
+    zstd_safe::{CParameter, ParamSwitch},
+};
+
+/// The maximum size of the compression window in bytes (2^CL_WINDOW_LIMIT).
+const CL_WINDOW_LIMIT: u32 = 22;
+
+fn compressor(target_block_size: u32) -> Encoder<'static, Vec<u8>> {
+    let mut encoder = Encoder::new(Vec::new(), 0).expect("Failed to create zstd encoder");
+    encoder
+        .set_parameter(CParameter::LiteralCompressionMode(ParamSwitch::Disable))
+        .expect("Failed to set literal compression mode");
+    encoder
+        .set_parameter(CParameter::WindowLog(CL_WINDOW_LIMIT))
+        .expect("Failed to set window log");
+    encoder
+        .set_parameter(CParameter::TargetCBlockSize(target_block_size))
+        .expect("Failed to set target block size");
+    encoder.include_checksum(false).expect("Failed to disable checksum");
+    encoder.include_magicbytes(false).expect("Failed to disable magic bytes");
+    encoder.include_dictid(false).expect("Failed to disable dictid");
+    encoder.include_contentsize(true).expect("Failed to include content size");
+    encoder
+}
 
 /// Computes the compression factor for a given RLP-encoded transaction.
-pub fn compute_compression_factor<T: AsRef<[u8]>>(_rlp_bytes: &T) -> U256 {
-    U256::from(10).saturating_mul(TX_L1_FEE_PRECISION)
+pub fn compute_compression_factor<T: AsRef<[u8]>>(rlp_bytes: &T) -> U256 {
+    // Instantiate the compressor
+    let mut compressor = compressor(CL_WINDOW_LIMIT);
+    let rlp_bytes_len = rlp_bytes.as_ref().len();
+
+    // Set the pledged source size to the length of the RLP bytes and write the bytes to the
+    // compressor.
+    // TODO: Is it possible this is fallible?
+    compressor
+        .set_pledged_src_size(Some(rlp_bytes_len as u64))
+        .expect("failed to set pledged source size");
+    // TODO: Is it possible this is fallible?
+    compressor.write_all(rlp_bytes.as_ref()).expect("failed to write RLP bytes to compressor");
+
+    // Finish the compression and get the result.
+    let result = compressor.finish().expect("failed to finish compression");
+
+    // compute the compression ratio
+    let compression_ratio =
+        ((rlp_bytes_len as f64 * TX_L1_FEE_PRECISION as f64) / result.len() as f64).floor() as u64;
+
+    U256::from(compression_ratio)
 }
 
 /// A generic wrrapper for a type that includes a compression factor and encoded bytes.
@@ -139,10 +177,14 @@ impl FromTxWithCompression<ScrollTxEnvelope> for ScrollTransactionIntoTxEnv<TxEn
 pub trait IntoCompressed<T> {
     /// Converts the type into a [`WithCompression`] instance, optionally using a
     /// [`ScrollTxCompressor`] to calculate the compression factor.
-    fn into_compressed(
-        self,
-        compression_provider: Option<&mut ScrollTxCompressionFactorCache>,
-    ) -> WithCompression<T>;
+    fn into_compressed(&self, compression_factor: U256) -> WithCompression<Recovered<&T>>;
+}
+
+impl<T: Encodable2718> IntoCompressed<T> for Recovered<&T> {
+    fn into_compressed(&self, compression_factor: U256) -> WithCompression<Recovered<&T>> {
+        let encoded_bytes = self.inner().encoded_2718();
+        WithCompression { value: *self, compression_factor, encoded_bytes: encoded_bytes.into() }
+    }
 }
 
 impl<Tx, T: RecoveredTx<Tx>> RecoveredTx<Tx> for WithCompression<T> {

crates/scroll/alloy/evm/src/tx/compression.rs

@@ -13,8 +13,7 @@ use scroll_alloy_consensus::{ScrollTxEnvelope, TxL1Message, L1_MESSAGE_TRANSACTI
 
 mod compression;
 pub use compression::{
-    compute_compression_factor, FromTxWithCompression, IntoCompressed,
-    ScrollTxCompressionFactorCache, WithCompression,
+    compute_compression_factor, FromTxWithCompression, IntoCompressed, WithCompression,
 };
 
 /// This structure wraps around a [`ScrollTransaction`] and allows us to implement the [`IntoTxEnv`]