fix(l1): use 256 bits for gas price in Legacy and EIP-2930 transactions

crates/common/trie/trie.rs

@@ -261,6 +261,11 @@ impl Trie {
         all_nodes: &BTreeMap<H256, Vec<u8>>,
         root_hash: H256,
     ) -> Result<NodeRef, TrieError> {
+        // If the root hash is of the empty trie then we can get away by setting the NodeRef to default
+        if root_hash == *EMPTY_TRIE_HASH {
+            return Ok(NodeRef::default());
+        }
+
         let root_rlp = all_nodes
             .get(&root_hash)
             .ok_or(TrieError::InconsistentTree)?;

crates/common/types/transaction.rs

@@ -163,7 +163,8 @@ impl RLPDecode for WrappedEIP4844Transaction {
 #[derive(Clone, Debug, PartialEq, Eq, Default, RSerialize, RDeserialize, Archive)]
 pub struct LegacyTransaction {
     pub nonce: u64,
-    pub gas_price: u64,
+    #[rkyv(with=crate::rkyv_utils::U256Wrapper)]
+    pub gas_price: U256,
     pub gas: u64,
     /// The recipient of the transaction.
     /// Create transactions contain a [`null`](RLP_NULL) value in this field.
@@ -186,7 +187,8 @@ pub struct LegacyTransaction {
 pub struct EIP2930Transaction {
     pub chain_id: u64,
     pub nonce: u64,
-    pub gas_price: u64,
+    #[rkyv(with=crate::rkyv_utils::U256Wrapper)]
+    pub gas_price: U256,
     pub gas_limit: u64,
     pub to: TxKind,
     #[rkyv(with=crate::rkyv_utils::U256Wrapper)]
@@ -351,20 +353,19 @@ impl Transaction {
         }
     }
 
-    fn calc_effective_gas_price(&self, base_fee_per_gas: Option<u64>) -> Option<u64> {
-        if self.max_fee_per_gas()? < base_fee_per_gas? {
+    fn calc_effective_gas_price(&self, base_fee_per_gas: Option<u64>) -> Option<U256> {
+        let base_fee = base_fee_per_gas?;
+        let max_fee = self.max_fee_per_gas()?;
+        if max_fee < base_fee {
             // This is invalid, can't calculate
             return None;
         }
 
-        let priority_fee_per_gas = min(
-            self.max_priority_fee()?,
-            self.max_fee_per_gas()?.saturating_sub(base_fee_per_gas?),
-        );
-        Some(priority_fee_per_gas + base_fee_per_gas?)
+        let priority_fee_per_gas = min(self.max_priority_fee()?, max_fee.saturating_sub(base_fee));
+        Some(U256::from(priority_fee_per_gas) + U256::from(base_fee))
     }
 
-    pub fn effective_gas_price(&self, base_fee_per_gas: Option<u64>) -> Option<u64> {
+    pub fn effective_gas_price(&self, base_fee_per_gas: Option<u64>) -> Option<U256> {
         match self.tx_type() {
             TxType::Legacy => Some(self.gas_price()),
             TxType::EIP2930 => Some(self.gas_price()),
@@ -379,14 +380,14 @@ impl Transaction {
         let price = match self.tx_type() {
             TxType::Legacy => self.gas_price(),
             TxType::EIP2930 => self.gas_price(),
-            TxType::EIP1559 => self.max_fee_per_gas()?,
-            TxType::EIP4844 => self.max_fee_per_gas()?,
-            TxType::EIP7702 => self.max_fee_per_gas()?,
+            TxType::EIP1559 => U256::from(self.max_fee_per_gas()?),
+            TxType::EIP4844 => U256::from(self.max_fee_per_gas()?),
+            TxType::EIP7702 => U256::from(self.max_fee_per_gas()?),
             TxType::Privileged => self.gas_price(),
         };
 
         Some(U256::saturating_add(
-            U256::saturating_mul(price.into(), self.gas_limit().into()),
+            U256::saturating_mul(price, self.gas_limit().into()),
             self.value(),
         ))
     }
@@ -1067,14 +1068,15 @@ impl Transaction {
         }
     }
 
-    pub fn gas_price(&self) -> u64 {
+    //TODO: It's not very correct to return gas price for legacy and eip-2930 txs but return the max fee per gas for the others, make necessary changes for it to be technically correct.
+    pub fn gas_price(&self) -> U256 {
         match self {
             Transaction::LegacyTransaction(tx) => tx.gas_price,
             Transaction::EIP2930Transaction(tx) => tx.gas_price,
-            Transaction::EIP1559Transaction(tx) => tx.max_fee_per_gas,
-            Transaction::EIP7702Transaction(tx) => tx.max_fee_per_gas,
-            Transaction::EIP4844Transaction(tx) => tx.max_fee_per_gas,
-            Transaction::PrivilegedL2Transaction(tx) => tx.max_fee_per_gas,
+            Transaction::EIP1559Transaction(tx) => U256::from(tx.max_fee_per_gas),
+            Transaction::EIP7702Transaction(tx) => U256::from(tx.max_fee_per_gas),
+            Transaction::EIP4844Transaction(tx) => U256::from(tx.max_fee_per_gas),
+            Transaction::PrivilegedL2Transaction(tx) => U256::from(tx.max_fee_per_gas),
         }
     }
 
@@ -1236,11 +1238,11 @@ impl Transaction {
     }
 
     pub fn gas_tip_cap(&self) -> u64 {
-        self.max_priority_fee().unwrap_or(self.gas_price())
+        self.max_priority_fee().unwrap_or(self.gas_price().as_u64())
     }
 
     pub fn gas_fee_cap(&self) -> u64 {
-        self.max_fee_per_gas().unwrap_or(self.gas_price())
+        self.max_fee_per_gas().unwrap_or(self.gas_price().as_u64())
     }
 
     pub fn effective_gas_tip(&self, base_fee: Option<u64>) -> Option<u64> {
@@ -1941,7 +1943,7 @@ mod serde_impl {
 
             Ok(LegacyTransaction {
                 nonce: deserialize_field::<U256, D>(&mut map, "nonce")?.as_u64(),
-                gas_price: deserialize_field::<U256, D>(&mut map, "gasPrice")?.as_u64(),
+                gas_price: deserialize_field::<U256, D>(&mut map, "gasPrice")?,
                 gas: deserialize_field::<U256, D>(&mut map, "gas")?.as_u64(),
                 to: deserialize_field::<TxKind, D>(&mut map, "to")?,
                 value: deserialize_field::<U256, D>(&mut map, "value")?,
@@ -1964,7 +1966,7 @@ mod serde_impl {
             Ok(EIP2930Transaction {
                 chain_id: deserialize_field::<U256, D>(&mut map, "chainId")?.as_u64(),
                 nonce: deserialize_field::<U256, D>(&mut map, "nonce")?.as_u64(),
-                gas_price: deserialize_field::<U256, D>(&mut map, "gasPrice")?.as_u64(),
+                gas_price: deserialize_field::<U256, D>(&mut map, "gasPrice")?,
                 gas_limit: deserialize_field::<U256, D>(&mut map, "gas")?.as_u64(),
                 to: deserialize_field::<TxKind, D>(&mut map, "to")?,
                 value: deserialize_field::<U256, D>(&mut map, "value")?,
@@ -2452,7 +2454,7 @@ mod serde_impl {
                 from: Address::default(),
                 gas: Some(value.gas),
                 value: value.value,
-                gas_price: value.gas_price,
+                gas_price: value.gas_price.as_u64(),
                 max_priority_fee_per_gas: None,
                 max_fee_per_gas: None,
                 max_fee_per_blob_gas: None,
@@ -2475,7 +2477,7 @@ mod serde_impl {
                 from: Address::default(),
                 gas: Some(value.gas_limit),
                 value: value.value,
-                gas_price: value.gas_price,
+                gas_price: value.gas_price.as_u64(),
                 max_priority_fee_per_gas: None,
                 max_fee_per_gas: None,
                 max_fee_per_blob_gas: None,
@@ -2626,7 +2628,7 @@ mod tests {
         let mut body = BlockBody::empty();
         let tx = LegacyTransaction {
             nonce: 0,
-            gas_price: 0x0a,
+            gas_price: U256::from(0x0a),
             gas: 0x05f5e100,
             to: TxKind::Call(hex!("1000000000000000000000000000000000000000").into()),
             value: 0.into(),
@@ -2653,7 +2655,7 @@ mod tests {
         let tx_eip2930 = EIP2930Transaction {
             chain_id: 3503995874084926u64,
             nonce: 7,
-            gas_price: 0x2dbf1f9a,
+            gas_price: U256::from(0x2dbf1f9a_u64),
             gas_limit: 0x186A0,
             to: TxKind::Call(hex!("7dcd17433742f4c0ca53122ab541d0ba67fc27df").into()),
             value: 2.into(),
@@ -2707,7 +2709,7 @@ mod tests {
         let tx = LegacyTransaction::decode(&encoded_tx_bytes).unwrap();
         let expected_tx = LegacyTransaction {
             nonce: 0,
-            gas_price: 1001000000,
+            gas_price: U256::from(1001000000u64),
             gas: 63000,
             to: TxKind::Call(Address::from_slice(
                 &hex::decode("6177843db3138ae69679A54b95cf345ED759450d").unwrap(),
@@ -3065,7 +3067,7 @@ mod tests {
     fn test_legacy_transaction_into_generic() {
         let legacy_tx = LegacyTransaction {
             nonce: 1,
-            gas_price: 20_000_000_000,
+            gas_price: U256::from(20_000_000_000u64),
             gas: 21000,
             to: TxKind::Call(
                 Address::from_str("0x742d35Cc6634C0532925a3b844Bc454e4438f44e").unwrap(),
@@ -3104,7 +3106,7 @@ mod tests {
         let eip2930_tx = EIP2930Transaction {
             chain_id: 1,
             nonce: 1,
-            gas_price: 20_000_000_000,
+            gas_price: U256::from(20_000_000_000u64),
             gas_limit: 21000,
             to: TxKind::Call(
                 Address::from_str("0x742d35Cc6634C0532925a3b844Bc454e4438f44e").unwrap(),

crates/networking/rpc/eth/mod.rs

@@ -110,7 +110,7 @@ pub mod test_utils {
     fn legacy_tx_for_test(nonce: u64) -> Transaction {
         Transaction::LegacyTransaction(LegacyTransaction {
             nonce,
-            gas_price: nonce * BASE_PRICE_IN_WEI,
+            gas_price: U256::from(nonce) * U256::from(BASE_PRICE_IN_WEI),
             gas: 10000,
             to: TxKind::Create,
             value: 100.into(),

crates/networking/rpc/types/receipt.rs

@@ -177,12 +177,12 @@ impl RpcReceiptTxInfo {
         let nonce = transaction.nonce();
         let from = transaction.sender()?;
         let transaction_hash = transaction.hash();
-        let effective_gas_price =
-            transaction
-                .effective_gas_price(base_fee_per_gas)
-                .ok_or(RpcErr::Internal(
-                    "Could not get effective gas price from tx".into(),
-                ))?;
+        let effective_gas_price = transaction
+            .effective_gas_price(base_fee_per_gas)
+            .ok_or(RpcErr::Internal(
+                "Could not get effective gas price from tx".into(),
+            ))?
+            .as_u64();
         let transaction_index = index;
         let (blob_gas_price, blob_gas_used) = match &transaction {
             Transaction::EIP4844Transaction(tx) => (

crates/vm/backends/levm/mod.rs

@@ -90,8 +90,7 @@ impl LEVM {
             .effective_gas_price(block_header.base_fee_per_gas)
             .ok_or(VMError::TxValidation(
                 TxValidationError::InsufficientMaxFeePerGas,
-            ))?
-            .into();
+            ))?;
 
         let config = EVMConfig::new_from_chain_config(&chain_config, block_header);
         let env = Environment {

crates/vm/levm/runner/src/input.rs

@@ -93,7 +93,7 @@ impl From<InputTransaction> for ethrex_common::types::LegacyTransaction {
     fn from(tx: InputTransaction) -> Self {
         ethrex_common::types::LegacyTransaction {
             nonce: 0,
-            gas_price: tx.gas_price.try_into().unwrap(),
+            gas_price: tx.gas_price,
             gas: tx.gas_limit,
             to: match tx.to {
                 Some(address) => ethrex_common::types::TxKind::Call(address),

tooling/ef_tests/blockchain/tests/all.rs

@@ -1,63 +1,64 @@
 use ef_tests_blockchain::test_runner::parse_and_execute;
+use ethrex_prover_lib::backend::Backend;
 use std::path::Path;
 
+// Enable only one of `sp1` or `stateless` at a time.
+#[cfg(all(feature = "sp1", feature = "stateless"))]
+compile_error!("Only one of `sp1` and `stateless` can be enabled at a time.");
+
 const TEST_FOLDER: &str = "vectors/";
 
-#[cfg(not(any(feature = "sp1", feature = "stateless")))]
-const SKIPPED_TESTS: &[&str] = &[
-    "system_contract_deployment",
-    "HighGasPriceParis", // Skipped because it sets a gas price higher than u64::MAX, which most clients don't implement and is a virtually impossible scenario
-    "dynamicAccountOverwriteEmpty_Paris", // Skipped because the scenario described is virtually impossible
-    "create2collisionStorageParis", // Skipped because it's not worth implementing since the scenario of the test is virtually impossible. See https://github.com/lambdaclass/ethrex/issues/1555
-    "RevertInCreateInInitCreate2Paris", // Skipped because it's not worth implementing since the scenario of the test is virtually impossible. See https://github.com/lambdaclass/ethrex/issues/1555
-    "test_tx_gas_larger_than_block_gas_limit",
-    "createBlobhashTx",
-    "RevertInCreateInInit_Paris",
+// Base skips shared by all runs.
+const SKIPPED_BASE: &[&str] = &[
+    // These tests contain accounts without nonce or code but have storage, which is a virtually impossible scenario. That's why we fail, but that's okay.
+    // When creating an account we don't check the storage root but just if it has nonce or code.
+    // Fix is on it's way on https://github.com/lambdaclass/ethrex/pull/4813
     "InitCollisionParis",
-    "ValueOverflowParis",
-];
-// We are skipping test_tx_gas_larger_than_block_gas_limit[fork_Osaka-blockchain_test-exceed_block_gas_limit_True] because of an
-// inconsistency on the expected exception. Exception returned is InvalidBlock(GasUsedMismatch(0x06000000,0x05000000)) while
-// exception expected GAS_ALLOWANCE_EXCEEDED. The thing is gas allowance exception is supposed to be thrown on any transaction
-// execution in case the transaction's gas limit is larger than the block's, which is not the case of this test.
-// This test has a block with "gasLimit": "0x055d4a80", "gasUsed": "0x05000000" and six transactions with "gasLimit": "0x01000000",
-// Apparently each transaction consumes up to its gas limit, which together is larger than the block's. Then when executing validate_gas_used
-// after the block's execution, it throws InvalidBlock(GasUsedMismatch(0x06000000,0x05000000)) on comparing the receipt's cumulative gas used agains the block's gas limit.
-#[cfg(any(feature = "sp1", feature = "stateless"))]
-const SKIPPED_TESTS: &[&str] = &[
-    // We skip most of these for the same reason we skip them in normal runs; since we need to do a normal run before running with the stateless backend
-    "system_contract_deployment",
-    "test_tx_gas_larger_than_block_gas_limit",
-    "HighGasPriceParis",
-    "dynamicAccountOverwriteEmpty_Paris",
-    "create2collisionStorageParis",
     "RevertInCreateInInitCreate2Paris",
-    "createBlobhashTx",
+    "create2collisionStorageParis",
+    "dynamicAccountOverwriteEmpty_Paris",
     "RevertInCreateInInit_Paris",
-    "InitCollisionParis",
+    // Skip because they take too long to run, but they pass
+    "static_Call50000_sha256",
+    "CALLBlake2f_MaxRounds",
+    "loopMul",
+    // It checks that withdrawal requests and consolidation requests accounts have code, which is always the case, except for this test.
+    // The fix is just an if, it's on its way on https://github.com/lambdaclass/ethrex/pull/4731
+    "system_contract_deployment",
+    // Skip because it tries to deserialize number > U256::MAX
     "ValueOverflowParis",
-    // We skip these two tests because they fail with stateless backend specifically. See https://github.com/lambdaclass/ethrex/issues/4502
-    "test_large_amount",
-    "test_multiple_withdrawals_same_address",
+    // Skip because it's a "Create" Blob Transaction, which doesn't actually exist. It never reaches the EVM because we can't even parse it as an actual Transaction.
+    "createBlobhashTx",
 ];
 
+// Extra skips added only for prover backends.
+#[cfg(feature = "sp1")]
+const EXTRA_SKIPS: &[&str] = &[
+    // I believe these tests fail because of how much stress they put into the zkVM, they probably cause an OOM though this should be checked
+    "static_Call50000",
+    "Return50000",
+    "static_Call1MB1024Calldepth",
+];
+#[cfg(not(feature = "sp1"))]
+const EXTRA_SKIPS: &[&str] = &[];
+
+// Select backend
+#[cfg(feature = "stateless")]
+const BACKEND: Option<Backend> = Some(Backend::Exec);
+#[cfg(feature = "sp1")]
+const BACKEND: Option<Backend> = Some(Backend::SP1);
 #[cfg(not(any(feature = "sp1", feature = "stateless")))]
-fn blockchain_runner(path: &Path) -> datatest_stable::Result<()> {
-    parse_and_execute(path, Some(SKIPPED_TESTS), None)
-}
+const BACKEND: Option<Backend> = None;
 
-// If `sp1` or `stateless` is enabled
-#[cfg(any(feature = "sp1", feature = "stateless"))]
 fn blockchain_runner(path: &Path) -> datatest_stable::Result<()> {
-    #[cfg(feature = "stateless")]
-    let backend = Some(ethrex_prover_lib::backend::Backend::Exec);
-    #[cfg(feature = "sp1")]
-    let backend = Some(ethrex_prover_lib::backend::Backend::SP1);
+    // Compose the final skip list
+    let skips: Vec<&'static str> = SKIPPED_BASE
+        .iter()
+        .copied()
+        .chain(EXTRA_SKIPS.iter().copied())
+        .collect();
 
-    parse_and_execute(path, Some(SKIPPED_TESTS), backend)
+    parse_and_execute(path, Some(&skips), BACKEND)
 }
 
 datatest_stable::harness!(blockchain_runner, TEST_FOLDER, r".*");
-
-#[cfg(any(all(feature = "sp1", feature = "stateless"),))]
-compile_error!("Only one of `sp1` and `stateless` can be enabled at a time.");

tooling/ef_tests/blockchain/types.rs

@@ -514,7 +514,7 @@ impl From<Transaction> for LegacyTransaction {
     fn from(val: Transaction) -> Self {
         LegacyTransaction {
             nonce: val.nonce.as_u64(),
-            gas_price: val.gas_price.unwrap_or_default().as_u64(), // TODO: Consider converting this into Option
+            gas_price: val.gas_price.unwrap_or_default(), // TODO: Consider converting this into Option
             gas: val.gas_limit.as_u64(),
             // to: match val.to {
             //     zero if zero == H160::zero() => TxKind::Create,
@@ -536,7 +536,7 @@ impl From<Transaction> for EIP2930Transaction {
         EIP2930Transaction {
             chain_id: val.chain_id.map(|id: U256| id.as_u64()).unwrap_or(1),
             nonce: val.nonce.as_u64(),
-            gas_price: val.gas_price.unwrap_or_default().as_u64(),
+            gas_price: val.gas_price.unwrap_or_default(),
             gas_limit: val.gas_limit.as_u64(),
             // to: match val.to {
             //     zero if zero == H160::zero() => TxKind::Create,

tooling/ef_tests/state/parser.rs

@@ -20,7 +20,7 @@ pub enum EFTestParseError {
     FailedToParseTestFile(String),
 }
 
-const IGNORED_TESTS: [&str; 11] = [
+const IGNORED_TESTS: &[&str] = &[
     "static_Call50000_sha256.json", // Skip because it takes longer to run than some tests, but not a huge deal.
     "CALLBlake2f_MaxRounds.json",   // Skip because it takes extremely long to run, but passes.
     "ValueOverflow.json",           // Skip because it tries to deserialize number > U256::MAX