Pass all London tests (#377)

* New TransactGasPrice struct and implement pre-EIP1559

* Implement EIP-1559

* Pass all London tests

* Run cargo fmt

Author: sorpaas

fuzz/src/main.rs

@@ -87,7 +87,7 @@ fn main() {
 			caller: H160::from_low_u64_be(1),
 			value: U256::zero(),
 			gas_limit,
-			gas_price,
+			gas_price: gas_price.into(),
 			access_list: vec![],
 			config: &config,
 		};
@@ -119,7 +119,7 @@ fn main() {
 			caller: H160::from_low_u64_be(1),
 			value: U256::zero(),
 			gas_limit,
-			gas_price,
+			gas_price: gas_price.into(),
 			access_list: vec![],
 			config: &config,
 		};
@@ -143,7 +143,7 @@ fn main() {
 			caller: user_address,
 			value: U256::zero(),
 			gas_limit,
-			gas_price,
+			gas_price: gas_price.into(),
 			access_list: vec![],
 			config: &config,
 		};

jsontests/src/run.rs

@@ -7,7 +7,7 @@ use std::{
 use evm::{
 	backend::{InMemoryAccount, InMemoryBackend, InMemoryEnvironment, OverlayedBackend},
 	interpreter::{Capture, runtime::GasState},
-	standard::{Config, TransactArgs, TransactArgsCallCreate},
+	standard::{Config, TransactArgs, TransactArgsCallCreate, TransactGasPrice},
 };
 use evm_mainnet::with_mainnet_invoker;
 use primitive_types::{H256, U256};
@@ -187,20 +187,27 @@ pub fn run_test(
 		Fork::ConstantinopleFix => Config::petersburg(),
 		Fork::Istanbul => Config::istanbul(),
 		Fork::Berlin => Config::berlin(),
+		Fork::London => Config::london(),
 		_ => return Err(Error::UnsupportedFork),
 	};
 	config_change(&mut config);
 
-	if test.post.expect_exception == Some(TestExpectException::TR_TypeNotSupported) {
+	match test.post.expect_exception {
 		// The `evm` crate does not understand transaction format, only the `ethereum` crate. So
 		// there's nothing for us to test here for `TR_TypeNotSupported`.
-		return Ok(());
-	}
+		Some(TestExpectException::TR_TypeNotSupported) => return Ok(()),
+
+		Some(TestExpectException::TR_RLP_WRONGVALUE) if test.transaction.value.0.is_err() => {
+			return Ok(());
+		}
+
+		// The responsibility to check gas limit / gas cap is on the block executor.
+		Some(TestExpectException::TR_FeeCapLessThanBlocks) => return Ok(()),
+		Some(TestExpectException::TR_NoFunds) => return Ok(()),
+		Some(TestExpectException::TR_GasLimitReached) => return Ok(()),
+		Some(TestExpectException::TR_TipGtFeeCap) => return Ok(()),
 
-	if test.post.expect_exception == Some(TestExpectException::TR_RLP_WRONGVALUE)
-		&& test.transaction.value.0.is_err()
-	{
-		return Ok(());
+		_ => (),
 	}
 
 	let env = InMemoryEnvironment {
@@ -221,7 +228,7 @@ pub fn run_test(
 		block_difficulty: test.env.current_difficulty,
 		block_randomness: test.env.current_random,
 		block_gas_limit: test.env.current_gas_limit,
-		block_base_fee_per_gas: test.transaction.gas_price,
+		block_base_fee_per_gas: test.env.current_base_fee.unwrap_or_default(),
 		chain_id: U256::one(),
 	};
 
@@ -249,6 +256,18 @@ pub fn run_test(
 		})
 		.collect::<BTreeMap<_, _>>();
 
+	let gas_price = if let Some(gas_price) = test.transaction.gas_price {
+		TransactGasPrice::Legacy(gas_price)
+	} else {
+		TransactGasPrice::FeeMarket {
+			max_priority: test
+				.transaction
+				.max_priority_fee_per_gas
+				.unwrap_or_default(),
+			max: test.transaction.max_fee_per_gas.unwrap_or_default(),
+		}
+	};
+
 	let args = if let Some(to) = test.transaction.to {
 		TransactArgs {
 			call_create: TransactArgsCallCreate::Call {
@@ -262,7 +281,7 @@ pub fn run_test(
 				.0
 				.map_err(|()| TestError::UnexpectedDecoding)?,
 			gas_limit: test.transaction.gas_limit,
-			gas_price: test.transaction.gas_price,
+			gas_price,
 			access_list: test
 				.transaction
 				.access_list
@@ -285,7 +304,7 @@ pub fn run_test(
 				.0
 				.map_err(|()| TestError::UnexpectedDecoding)?,
 			gas_limit: test.transaction.gas_limit,
-			gas_price: test.transaction.gas_price,
+			gas_price,
 			access_list: test
 				.transaction
 				.access_list
@@ -393,9 +412,9 @@ pub fn run_test(
 						transaction: TestMultiTransaction {
 							data: vec![HexBytes(test.transaction.data)],
 							gas_limit: vec![test.transaction.gas_limit],
-							gas_price: Some(test.transaction.gas_price),
-							max_fee_per_gas: None,
-							max_priority_fee_per_gas: test.transaction.gas_priority_fee,
+							gas_price: test.transaction.gas_price,
+							max_fee_per_gas: test.transaction.max_fee_per_gas,
+							max_priority_fee_per_gas: test.transaction.max_priority_fee_per_gas,
 							nonce: test.transaction.nonce,
 							secret_key: test.transaction.secret_key,
 							sender: test.transaction.sender,

jsontests/src/types.rs

@@ -92,11 +92,9 @@ impl TestMulti {
 					transaction: TestTransaction {
 						data: self.transaction.data[post_state.indexes.data].0.clone(),
 						gas_limit: self.transaction.gas_limit[post_state.indexes.gas],
-						gas_price: self
-							.transaction
-							.gas_price
-							.unwrap_or(self.env.current_base_fee.unwrap_or_default()),
-						gas_priority_fee: self.transaction.max_priority_fee_per_gas,
+						gas_price: self.transaction.gas_price,
+						max_priority_fee_per_gas: self.transaction.max_priority_fee_per_gas,
+						max_fee_per_gas: self.transaction.max_fee_per_gas,
 						nonce: self.transaction.nonce,
 						secret_key: self.transaction.secret_key,
 						sender: self.transaction.sender,
@@ -315,8 +313,9 @@ pub struct TestAccessListItem {
 pub struct TestTransaction {
 	pub data: Vec<u8>,
 	pub gas_limit: U256,
-	pub gas_price: U256,
-	pub gas_priority_fee: Option<U256>,
+	pub gas_price: Option<U256>,
+	pub max_priority_fee_per_gas: Option<U256>,
+	pub max_fee_per_gas: Option<U256>,
 	pub nonce: U256,
 	pub secret_key: H256,
 	pub sender: H160,

precompile/src/lib.rs

@@ -1,7 +1,7 @@
 //! Standard EVM precompiles.
 
 #![deny(warnings)]
-// #![forbid(unsafe_code, unused_variables)]
+#![forbid(unsafe_code, unused_variables)]
 #![warn(missing_docs)]
 #![cfg_attr(not(feature = "std"), no_std)]
 

src/backend/overlayed.rs

@@ -268,6 +268,7 @@ impl<B: RuntimeBaseBackend> RuntimeBackend for OverlayedBackend<'_, B> {
 				self.substate.touched.insert(address);
 			}
 			TouchKind::Coinbase => {
+				self.substate.touched.insert(address);
 				if self.config.eip3651_warm_coinbase_address {
 					self.substate.accessed.insert((address, None));
 				}

src/standard/config.rs

@@ -260,12 +260,20 @@ impl Config {
 
 	/// Gas paid for sstore refund.
 	pub fn refund_sstore_clears(&self) -> i64 {
-		15000
+		if self.eip3529_decrease_clears_refund {
+			4800
+		} else {
+			15000
+		}
 	}
 
 	/// EIP-3529
 	pub fn max_refund_quotient(&self) -> u64 {
-		2
+		if self.eip3529_decrease_clears_refund {
+			5
+		} else {
+			2
+		}
 	}
 
 	/// Gas paid for BALANCE opcode.

src/standard/invoker/mod.rs

@@ -71,8 +71,104 @@ pub enum TransactValueCallCreate {
 pub struct TransactValue {
 	/// Call/Create status.
 	pub call_create: TransactValueCallCreate,
-	/// Used gas minus the refund.
-	pub effective_gas: U256,
+	/// Used gas.
+	pub used_gas: U256,
+}
+
+/// Transact gas price.
+#[derive(Clone, Debug, Copy, Eq, PartialEq)]
+pub enum TransactGasPrice {
+	/// Legacy gas price.
+	Legacy(U256),
+	/// EIP-1559 fee market.
+	FeeMarket {
+		/// `max_priority_fee_per_gas` according to EIP-1559.
+		max_priority: U256,
+		/// `max_fee_per_gas` according to EIP-1559.
+		max: U256,
+	},
+}
+
+impl TransactGasPrice {
+	/// Caller fee.
+	pub fn fee<H: RuntimeEnvironment>(
+		&self,
+		gas_limit: U256,
+		config: &Config,
+		handler: &H,
+	) -> U256 {
+		let effective_gas_price = self.effective_gas_price(config, handler);
+		gas_limit.saturating_mul(effective_gas_price)
+	}
+
+	/// Refunded caller fee after call.
+	pub fn refunded_fee<H: RuntimeEnvironment>(
+		&self,
+		refunded_gas: U256,
+		config: &Config,
+		handler: &H,
+	) -> U256 {
+		let effective_gas_price = self.effective_gas_price(config, handler);
+		refunded_gas.saturating_mul(effective_gas_price)
+	}
+
+	/// Coinbase reward.
+	pub fn coinbase_reward<H: RuntimeEnvironment>(
+		&self,
+		used_gas: U256,
+		config: &Config,
+		handler: &H,
+	) -> U256 {
+		if config.eip1559_fee_market {
+			let max_priority = match self {
+				Self::Legacy(gas_price) => *gas_price,
+				Self::FeeMarket { max_priority, .. } => *max_priority,
+			};
+			let max = match self {
+				Self::Legacy(gas_price) => *gas_price,
+				Self::FeeMarket { max, .. } => *max,
+			};
+			let priority = min(
+				max_priority,
+				max.saturating_sub(handler.block_base_fee_per_gas()),
+			);
+			used_gas.saturating_mul(priority)
+		} else {
+			let effective_gas_price = self.effective_gas_price(config, handler);
+			used_gas.saturating_mul(effective_gas_price)
+		}
+	}
+
+	/// Effective gas price as returned by `GASPRICE` opcode.
+	pub fn effective_gas_price<H: RuntimeEnvironment>(&self, config: &Config, handler: &H) -> U256 {
+		if config.eip1559_fee_market {
+			let max_priority = match self {
+				Self::Legacy(gas_price) => *gas_price,
+				Self::FeeMarket { max_priority, .. } => *max_priority,
+			};
+			let max = match self {
+				Self::Legacy(gas_price) => *gas_price,
+				Self::FeeMarket { max, .. } => *max,
+			};
+
+			let priority = min(
+				max_priority,
+				max.saturating_sub(handler.block_base_fee_per_gas()),
+			);
+			priority.saturating_add(handler.block_base_fee_per_gas())
+		} else {
+			match self {
+				Self::Legacy(gas_price) => *gas_price,
+				Self::FeeMarket { max_priority, .. } => *max_priority,
+			}
+		}
+	}
+}
+
+impl From<U256> for TransactGasPrice {
+	fn from(gas_price: U256) -> Self {
+		Self::Legacy(gas_price)
+	}
 }
 
 /// The invoke used in a top-layer transaction stack.
@@ -82,7 +178,7 @@ pub struct TransactInvoke<'config> {
 	/// Gas limit.
 	pub gas_limit: U256,
 	/// Gas price.
-	pub gas_price: U256,
+	pub gas_price: TransactGasPrice,
 	/// Caller.
 	pub caller: H160,
 	/// Config used for the transaction.
@@ -120,7 +216,7 @@ pub struct TransactArgs<'config> {
 	/// Transaction gas limit.
 	pub gas_limit: U256,
 	/// Transaction gas price.
-	pub gas_price: U256,
+	pub gas_price: TransactGasPrice,
 	/// Access list information, in the format of (address, storage keys).
 	pub access_list: Vec<(H160, Vec<H256>)>,
 	/// Config of this arg.
@@ -187,9 +283,11 @@ where
 	> {
 		let caller = AsRef::<TransactArgs>::as_ref(&args).caller;
 		let gas_price = AsRef::<TransactArgs>::as_ref(&args).gas_price;
-		let gas_fee = AsRef::<TransactArgs>::as_ref(&args)
-			.gas_limit
-			.saturating_mul(gas_price);
+		let gas_fee = gas_price.fee(
+			AsRef::<TransactArgs>::as_ref(&args).gas_limit,
+			AsRef::<TransactArgs>::as_ref(&args).config,
+			handler,
+		);
 		let coinbase = handler.block_coinbase();
 
 		let address = match &AsRef::<TransactArgs>::as_ref(&args).call_create {
@@ -225,6 +323,8 @@ where
 			config: AsRef::<TransactArgs>::as_ref(&args).config,
 		};
 
+		handler.mark_hot(coinbase, TouchKind::Coinbase);
+
 		if handler.code_size(caller) != U256::zero() {
 			handler.push_substate();
 			return Ok((
@@ -276,7 +376,8 @@ where
 		};
 		let transaction_context = TransactionContext {
 			origin: caller,
-			gas_price,
+			gas_price: gas_price
+				.effective_gas_price(AsRef::<TransactArgs>::as_ref(&args).config, handler),
 		};
 		let transfer = Transfer {
 			source: caller,
@@ -297,7 +398,6 @@ where
 			}
 		}
 
-		handler.mark_hot(coinbase, TouchKind::Coinbase);
 		handler.mark_hot(caller, TouchKind::Access);
 		handler.mark_hot(caller, TouchKind::StateChange);
 		handler.mark_hot(address, TouchKind::Access);
@@ -423,27 +523,19 @@ where
 			}
 		}
 
-		let refunded_fee = effective_gas.saturating_mul(invoke.gas_price);
+		let used_gas = invoke.gas_limit.saturating_sub(effective_gas);
+		let refunded_fee = invoke
+			.gas_price
+			.refunded_fee(effective_gas, invoke.config, handler);
 		handler.deposit(invoke.caller, refunded_fee);
-		// Reward coinbase address
-		// EIP-1559 updated the fee system so that miners only get to keep the priority fee.
-		// The base fee is always burned.
-		let coinbase_gas_price = if invoke.config.eip1559_fee_market {
-			invoke
-				.gas_price
-				.saturating_sub(handler.block_base_fee_per_gas())
-		} else {
-			invoke.gas_price
-		};
 		let coinbase_reward = invoke
-			.gas_limit
-			.saturating_mul(coinbase_gas_price)
-			.saturating_sub(refunded_fee);
+			.gas_price
+			.coinbase_reward(used_gas, invoke.config, handler);
 		handler.deposit(handler.block_coinbase(), coinbase_reward);
 
 		result.map(|call_create| TransactValue {
 			call_create,
-			effective_gas,
+			used_gas,
 		})
 	}