fix lint

Author: randygrok

Cargo.lock

@@ -48,6 +48,7 @@ reth-transaction-pool = { git = "https://github.com/paradigmxyz/reth.git", tag =
 reth-network = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
 reth-network-types = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
 reth-chain-state = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
+reth-db-api = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
 reth-ethereum = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
 reth-ethereum-cli = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
 reth-basic-payload-builder = { git = "https://github.com/paradigmxyz/reth.git", tag = "v1.8.4" }
@@ -119,6 +120,9 @@ alloy-genesis = { version = "1.0.37", default-features = false }
 alloy-rpc-types-txpool = { version = "1.0.37", default-features = false }
 alloy-sol-types = { version = "1.3.1", default-features = false }
 
+# Utility dependencies
+bytes = "1.10.1"
+
 revm-inspector = { version = "10.0.1" }
 # Core dependencies
 eyre = "0.6"

Cargo.toml

@@ -10,7 +10,9 @@ alloy-consensus = { workspace = true }
 alloy-eips = { workspace = true, features = ["serde"] }
 alloy-primitives = { workspace = true, features = ["k256", "rlp", "serde"] }
 alloy-rlp = { workspace = true, features = ["derive"] }
+bytes = { workspace = true }
 reth-codecs = { workspace = true }
+reth-db-api = { workspace = true }
 reth-ethereum-primitives = { workspace = true }
 reth-primitives-traits = { workspace = true, features = ["serde-bincode-compat"] }
 serde = { workspace = true, features = ["derive"] }

crates/ev-primitives/Cargo.toml

@@ -12,6 +12,10 @@ use reth_codecs::{
     txtype::COMPACT_EXTENDED_IDENTIFIER_FLAG,
     Compact,
 };
+use reth_db_api::{
+    table::{Compress, Decompress},
+    DatabaseError,
+};
 use reth_primitives_traits::{InMemorySize, SignedTransaction};
 use std::vec::Vec;
 
@@ -21,7 +25,17 @@ pub const EVNODE_TX_TYPE_ID: u8 = 0x76;
 pub const EVNODE_SPONSOR_DOMAIN: u8 = 0x78;
 
 /// Single call entry in an EvNode transaction.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, RlpEncodable, RlpDecodable, serde::Serialize, serde::Deserialize)]
+#[derive(
+    Clone,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    RlpEncodable,
+    RlpDecodable,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct Call {
     /// Destination (CALL or CREATE).
     pub to: TxKind,
@@ -82,7 +96,10 @@ impl EvNodeTransaction {
     }
 
     /// Recovers the executor address from the provided signature.
-    pub fn recover_executor(&self, signature: &Signature) -> Result<Address, alloy_primitives::SignatureError> {
+    pub fn recover_executor(
+        &self,
+        signature: &Signature,
+    ) -> Result<Address, alloy_primitives::SignatureError> {
         signature.recover_address_from_prehash(&self.executor_signing_hash())
     }
 
@@ -101,14 +118,25 @@ impl EvNodeTransaction {
 
     fn encoded_payload(&self, fee_payer_signature: Option<&Signature>) -> Vec<u8> {
         let payload_len = self.payload_fields_length(fee_payer_signature);
-        let mut out = Vec::with_capacity(Header { list: true, payload_length: payload_len }.length_with_payload());
-        Header { list: true, payload_length: payload_len }.encode(&mut out);
+        let mut out = Vec::with_capacity(
+            Header {
+                list: true,
+                payload_length: payload_len,
+            }
+            .length_with_payload(),
+        );
+        Header {
+            list: true,
+            payload_length: payload_len,
+        }
+        .encode(&mut out);
         self.encode_payload_fields(&mut out, fee_payer_signature);
         out
     }
 
     fn encoded_payload_with_executor(&self, executor: Address) -> Vec<u8> {
-        let mut out = Vec::with_capacity(self.payload_fields_length(self.fee_payer_signature.as_ref()) + 32);
+        let mut out =
+            Vec::with_capacity(self.payload_fields_length(self.fee_payer_signature.as_ref()) + 32);
         out.extend_from_slice(executor.as_slice());
         self.encode_payload_fields(&mut out, self.fee_payer_signature.as_ref());
         out
@@ -139,7 +167,7 @@ impl EvNodeTransaction {
 
 impl Transaction for EvNodeTransaction {
     fn chain_id(&self) -> Option<alloy_primitives::ChainId> {
-        Some(self.chain_id.into())
+        Some(self.chain_id)
     }
 
     fn nonce(&self) -> u64 {
@@ -189,7 +217,9 @@ impl Transaction for EvNodeTransaction {
     }
 
     fn kind(&self) -> TxKind {
-        self.first_call().map(|call| call.to).unwrap_or(TxKind::Create)
+        self.first_call()
+            .map(|call| call.to)
+            .unwrap_or(TxKind::Create)
     }
 
     fn is_create(&self) -> bool {
@@ -228,18 +258,26 @@ impl alloy_eips::Typed2718 for EvNodeTransaction {
 
 impl SignableTransaction<Signature> for EvNodeTransaction {
     fn set_chain_id(&mut self, chain_id: alloy_primitives::ChainId) {
-        self.chain_id = chain_id.into();
+        self.chain_id = chain_id;
     }
 
     fn encode_for_signing(&self, out: &mut dyn BufMut) {
         out.put_u8(EVNODE_TX_TYPE_ID);
         let payload_len = self.payload_fields_length(None);
-        Header { list: true, payload_length: payload_len }.encode(out);
+        Header {
+            list: true,
+            payload_length: payload_len,
+        }
+        .encode(out);
         self.encode_payload_fields(out, None);
     }
 
     fn payload_len_for_signature(&self) -> usize {
-        1 + Header { list: true, payload_length: self.payload_fields_length(None) }.length_with_payload()
+        1 + Header {
+            list: true,
+            payload_length: self.payload_fields_length(None),
+        }
+        .length_with_payload()
     }
 }
 
@@ -272,7 +310,11 @@ impl RlpEcdsaDecodableTx for EvNodeTransaction {
 
 impl Encodable for EvNodeTransaction {
     fn length(&self) -> usize {
-        Header { list: true, payload_length: self.rlp_encoded_fields_length() }.length_with_payload()
+        Header {
+            list: true,
+            payload_length: self.rlp_encoded_fields_length(),
+        }
+        .length_with_payload()
     }
 
     fn encode(&self, out: &mut dyn BufMut) {
@@ -418,8 +460,9 @@ impl FromTxCompact for EvTxEnvelope {
     {
         match tx_type {
             EvTxType::Ethereum(inner) => {
-                let (tx, buf) =
-                    reth_ethereum_primitives::TransactionSigned::from_tx_compact(buf, inner, signature);
+                let (tx, buf) = reth_ethereum_primitives::TransactionSigned::from_tx_compact(
+                    buf, inner, signature,
+                );
                 (Self::Ethereum(tx), buf)
             }
             EvTxType::EvNode => {
@@ -459,6 +502,21 @@ impl SignedTransaction for EvTxEnvelope {}
 
 impl reth_primitives_traits::serde_bincode_compat::RlpBincode for EvTxEnvelope {}
 
+impl Compress for EvTxEnvelope {
+    type Compressed = Vec<u8>;
+
+    fn compress_to_buf<B: bytes::BufMut + AsMut<[u8]>>(&self, buf: &mut B) {
+        let _ = Compact::to_compact(self, buf);
+    }
+}
+
+impl Decompress for EvTxEnvelope {
+    fn decompress(value: &[u8]) -> Result<Self, DatabaseError> {
+        let (obj, _) = Compact::from_compact(value, value.len());
+        Ok(obj)
+    }
+}
+
 fn optional_signature_length(value: Option<&Signature>) -> usize {
     match value {
         Some(sig) => sig.as_bytes().as_slice().length(),
@@ -478,7 +536,9 @@ fn decode_optional_signature(buf: &mut &[u8]) -> alloy_rlp::Result<Option<Signat
     if bytes.is_empty() {
         return Ok(None);
     }
-    let raw: [u8; 65] = bytes.try_into().map_err(|_| alloy_rlp::Error::UnexpectedLength)?;
+    let raw: [u8; 65] = bytes
+        .try_into()
+        .map_err(|_| alloy_rlp::Error::UnexpectedLength)?;
     Signature::from_raw_array(&raw)
         .map(Some)
         .map_err(|_| alloy_rlp::Error::Custom("invalid signature bytes"))
@@ -502,7 +562,11 @@ mod tests {
             max_priority_fee_per_gas: 1,
             max_fee_per_gas: 2,
             gas_limit: 30_000,
-            calls: vec![Call { to: TxKind::Create, value: U256::from(1), input: Bytes::new() }],
+            calls: vec![Call {
+                to: TxKind::Create,
+                value: U256::from(1),
+                input: Bytes::new(),
+            }],
             access_list: AccessList::default(),
             fee_payer_signature: None,
         }

crates/ev-primitives/src/tx.rs

@@ -1,7 +1,11 @@
 //! Execution traits for [`EvEvm`], mirroring the Reth mainnet implementations
 //! while inserting the EV-specific handler that redirects the base fee.
 
-use crate::{evm::EvEvm, handler::EvHandler, tx_env::{BatchCallsTx, SponsorPayerTx}};
+use crate::{
+    evm::EvEvm,
+    handler::EvHandler,
+    tx_env::{BatchCallsTx, SponsorPayerTx},
+};
 use alloy_primitives::{Address, Bytes};
 use reth_revm::revm::{
     context::{result::ExecResultAndState, ContextSetters},
@@ -75,8 +79,7 @@ where
             Db: DatabaseCommit,
             Journal: JournalTr<State = EvmState>,
             Tx: SponsorPayerTx + BatchCallsTx,
-        >
-        + ContextSetters,
+        > + ContextSetters,
     <CTX as ContextTr>::Tx: Clone,
     PRECOMP: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
@@ -87,8 +90,10 @@ where
 
 impl<CTX, INSP, PRECOMP> InspectEvm for EvEvm<CTX, INSP, PRECOMP>
 where
-    CTX: ContextTr<Journal: JournalTr<State = EvmState> + JournalExt, Tx: SponsorPayerTx + BatchCallsTx>
-        + ContextSetters,
+    CTX: ContextTr<
+            Journal: JournalTr<State = EvmState> + JournalExt,
+            Tx: SponsorPayerTx + BatchCallsTx,
+        > + ContextSetters,
     <CTX as ContextTr>::Tx: Clone,
     INSP: Inspector<CTX, EthInterpreter>,
     PRECOMP: PrecompileProvider<CTX, Output = InterpreterResult>,
@@ -114,8 +119,7 @@ where
             Journal: JournalTr<State = EvmState> + JournalExt,
             Db: DatabaseCommit,
             Tx: SponsorPayerTx + BatchCallsTx,
-        >
-        + ContextSetters,
+        > + ContextSetters,
     <CTX as ContextTr>::Tx: Clone,
     INSP: Inspector<CTX, EthInterpreter>,
     PRECOMP: PrecompileProvider<CTX, Output = InterpreterResult>,
@@ -124,8 +128,10 @@ where
 
 impl<CTX, INSP, PRECOMP> SystemCallEvm for EvEvm<CTX, INSP, PRECOMP>
 where
-    CTX: ContextTr<Journal: JournalTr<State = EvmState>, Tx: SystemCallTx + SponsorPayerTx + BatchCallsTx>
-        + ContextSetters,
+    CTX: ContextTr<
+            Journal: JournalTr<State = EvmState>,
+            Tx: SystemCallTx + SponsorPayerTx + BatchCallsTx,
+        > + ContextSetters,
     <CTX as ContextTr>::Tx: Clone,
     PRECOMP: PrecompileProvider<CTX, Output = InterpreterResult>,
 {
@@ -154,8 +160,7 @@ where
     CTX: ContextTr<
             Journal: JournalTr<State = EvmState> + JournalExt,
             Tx: SystemCallTx + SponsorPayerTx + BatchCallsTx,
-        >
-        + ContextSetters,
+        > + ContextSetters,
     <CTX as ContextTr>::Tx: Clone,
     INSP: Inspector<CTX, EthInterpreter>,
     PRECOMP: PrecompileProvider<CTX, Output = InterpreterResult>,

crates/ev-revm/src/api/exec.rs

@@ -9,6 +9,7 @@ use alloy_evm::{
 use alloy_primitives::{Address, U256};
 use ev_precompiles::mint::{MintPrecompile, MINT_PRECOMPILE_ADDR};
 use reth_evm_ethereum::EthEvmConfig;
+use reth_revm::revm::context_interface::journaled_state::JournalTr;
 use reth_revm::{
     inspector::NoOpInspector,
     revm::{
@@ -20,11 +21,10 @@ use reth_revm::{
         handler::instructions::EthInstructions,
         interpreter::interpreter::EthInterpreter,
         precompile::{PrecompileSpecId, Precompiles},
-        Context, Inspector,
         primitives::hardfork::SpecId,
+        Context, Inspector,
     },
 };
-use reth_revm::revm::context_interface::journaled_state::JournalTr;
 use std::sync::Arc;
 
 /// Settings for enabling the base-fee redirect at a specific block height.
@@ -227,7 +227,12 @@ pub struct EvTxEvmFactory {
     contract_size_limit: Option<ContractSizeLimitSettings>,
 }
 
-type EvEvmContext<DB> = Context<reth_revm::revm::context::BlockEnv, EvTxEnv, reth_revm::revm::context::CfgEnv<SpecId>, DB>;
+type EvEvmContext<DB> = Context<
+    reth_revm::revm::context::BlockEnv,
+    EvTxEnv,
+    reth_revm::revm::context::CfgEnv<SpecId>,
+    DB,
+>;
 type EvRevmEvm<DB, I> = RevmEvm<
     EvEvmContext<DB>,
     I,
@@ -237,12 +242,17 @@ type EvRevmEvm<DB, I> = RevmEvm<
 >;
 
 impl EvTxEvmFactory {
+    /// Creates a new EV EVM factory with optional redirect and precompile settings.
     pub const fn new(
         redirect: Option<BaseFeeRedirectSettings>,
         mint_precompile: Option<MintPrecompileSettings>,
         contract_size_limit: Option<ContractSizeLimitSettings>,
     ) -> Self {
-        Self { redirect, mint_precompile, contract_size_limit }
+        Self {
+            redirect,
+            mint_precompile,
+            contract_size_limit,
+        }
     }
 
     fn contract_size_limit_for_block(&self, block_number: U256) -> Option<usize> {
@@ -291,9 +301,9 @@ impl EvTxEvmFactory {
         env: EvmEnv<SpecId>,
         inspector: I,
     ) -> EvRevmEvm<DB, I> {
-        let precompiles = PrecompilesMap::from_static(Precompiles::new(PrecompileSpecId::from_spec_id(
-            env.cfg_env.spec,
-        )));
+        let precompiles = PrecompilesMap::from_static(Precompiles::new(
+            PrecompileSpecId::from_spec_id(env.cfg_env.spec),
+        ));
 
         let mut journaled_state = reth_revm::revm::Journal::new(db);
         journaled_state.set_spec_id(env.cfg_env.spec);