Pass all Berlin tests (#376)

* Berlin modexp gas cost

* Handle create transaction access list

* Access list is inside the substack

* Fix some missing gas costs in access list

* Mark hot for precompiles

* Cargo fmt

* Do not warm coinbase in Berlin

* Fix state touch

* Pass all berlin tests

Author: sorpaas

fuzz/src/main.rs

@@ -223,7 +223,7 @@ fn fuzz_transact(
 	usize,
 	usize,
 ) {
-	let mut overlayed_backend = OverlayedBackend::new(backend, Default::default(), &config.runtime);
+	let mut overlayed_backend = OverlayedBackend::new(backend, &config.runtime);
 	#[cfg(not(feature = "fuzzing"))]
 	let now = std::time::Instant::now();
 

interpreter/src/runtime.rs

@@ -34,6 +34,8 @@ pub struct RuntimeConfig {
 	pub eip7610_create_check_storage: bool,
 	/// EIP-6780: selfdestruct deletet contract only if called in the same tx as creation
 	pub eip6780_suicide_only_in_same_tx: bool,
+	/// EIP-3651
+	pub eip3651_warm_coinbase_address: bool,
 }
 
 impl RuntimeConfig {
@@ -43,6 +45,7 @@ impl RuntimeConfig {
 			eip161_empty_check: true,
 			eip7610_create_check_storage: true,
 			eip6780_suicide_only_in_same_tx: false,
+			eip3651_warm_coinbase_address: false,
 		}
 	}
 
@@ -52,6 +55,7 @@ impl RuntimeConfig {
 			eip161_empty_check: false,
 			eip6780_suicide_only_in_same_tx: false,
 			eip7610_create_check_storage: true,
+			eip3651_warm_coinbase_address: false,
 		}
 	}
 }

jsontests/src/run.rs

@@ -1,12 +1,12 @@
 use std::{
-	collections::{BTreeMap, BTreeSet},
+	collections::BTreeMap,
 	fs::{self, File},
 	io::{BufReader, BufWriter},
 };
 
 use evm::{
 	backend::{InMemoryAccount, InMemoryBackend, InMemoryEnvironment, OverlayedBackend},
-	interpreter::{Capture, runtime::GasState, utils::u256_to_h256},
+	interpreter::{Capture, runtime::GasState},
 	standard::{Config, TransactArgs, TransactArgsCallCreate},
 };
 use evm_mainnet::with_mainnet_invoker;
@@ -186,6 +186,7 @@ pub fn run_test(
 		Fork::Byzantium => Config::byzantium(),
 		Fork::ConstantinopleFix => Config::petersburg(),
 		Fork::Istanbul => Config::istanbul(),
+		Fork::Berlin => Config::berlin(),
 		_ => return Err(Error::UnsupportedFork),
 	};
 	config_change(&mut config);
@@ -296,23 +297,13 @@ pub fn run_test(
 		}
 	};
 
-	let initial_accessed = {
-		let mut hots = BTreeSet::new();
-		for i in 1..10 {
-			hots.insert((u256_to_h256(U256::from(i)).into(), None));
-		}
-		hots
-	};
-
 	let base_backend = InMemoryBackend {
 		environment: env,
 		state,
 	};
 
-	let mut run_backend =
-		OverlayedBackend::new(&base_backend, initial_accessed.clone(), &config.runtime);
-	let mut step_backend =
-		OverlayedBackend::new(&base_backend, initial_accessed.clone(), &config.runtime);
+	let mut run_backend = OverlayedBackend::new(&base_backend, &config.runtime);
+	let mut step_backend = OverlayedBackend::new(&base_backend, &config.runtime);
 
 	// Run
 	let run_result = evm_mainnet::transact(args.clone(), &mut run_backend);

precompile/src/lib.rs

@@ -29,12 +29,15 @@ use crate::{
 		Bn128AddByzantium, Bn128AddIstanbul, Bn128MulByzantium, Bn128MulIstanbul,
 		Bn128PairingByzantium, Bn128PairingIstanbul,
 	},
-	modexp::Modexp,
+	modexp::{ModexpBerlin, ModexpByzantium},
 	simple::{ECRecover, Identity, Ripemd160, Sha256},
 };
 use evm::{
 	GasMutState,
-	interpreter::{ExitError, ExitException, ExitResult, runtime::RuntimeState},
+	interpreter::{
+		ExitError, ExitException, ExitResult,
+		runtime::{RuntimeBackend, RuntimeState, TouchKind},
+	},
 	standard::{Config, PrecompileSet},
 };
 use primitive_types::H160;
@@ -46,9 +49,33 @@ trait PurePrecompile<G> {
 /// The standard precompile set on Ethereum mainnet.
 pub struct StandardPrecompileSet;
 
-impl<G: AsRef<RuntimeState> + AsRef<Config> + GasMutState, H> PrecompileSet<G, H>
+impl<G: AsRef<RuntimeState> + AsRef<Config> + GasMutState, H: RuntimeBackend> PrecompileSet<G, H>
 	for StandardPrecompileSet
 {
+	fn on_transaction(&self, state: &mut G, handler: &mut H) {
+		handler.mark_hot(address(1), TouchKind::Access);
+		handler.mark_hot(address(2), TouchKind::Access);
+		handler.mark_hot(address(3), TouchKind::Access);
+		handler.mark_hot(address(4), TouchKind::Access);
+
+		if AsRef::<Config>::as_ref(state).eip198_modexp_precompile {
+			handler.mark_hot(address(5), TouchKind::Access);
+		}
+
+		if AsRef::<Config>::as_ref(state).eip196_ec_add_mul_precompile {
+			handler.mark_hot(address(6), TouchKind::Access);
+			handler.mark_hot(address(7), TouchKind::Access);
+		}
+
+		if AsRef::<Config>::as_ref(state).eip197_ec_pairing_precompile {
+			handler.mark_hot(address(8), TouchKind::Access);
+		}
+
+		if AsRef::<Config>::as_ref(state).eip152_blake_2f_precompile {
+			handler.mark_hot(address(9), TouchKind::Access);
+		}
+	}
+
 	fn execute(
 		&self,
 		code_address: H160,
@@ -67,7 +94,11 @@ impl<G: AsRef<RuntimeState> + AsRef<Config> + GasMutState, H> PrecompileSet<G, H
 		} else if AsRef::<Config>::as_ref(gasometer).eip198_modexp_precompile
 			&& code_address == address(5)
 		{
-			Some(Modexp.execute(input, gasometer))
+			if AsRef::<Config>::as_ref(gasometer).eip2565_lower_modexp {
+				Some(ModexpBerlin.execute(input, gasometer))
+			} else {
+				Some(ModexpByzantium.execute(input, gasometer))
+			}
 		} else if AsRef::<Config>::as_ref(gasometer).eip196_ec_add_mul_precompile
 			&& code_address == address(6)
 		{

precompile/src/modexp.rs

@@ -8,8 +8,6 @@ use primitive_types::U256;
 
 use crate::PurePrecompile;
 
-pub struct Modexp;
-
 fn modexp(base: &[u8], exponent: &[u8], modulus: &[u8]) -> Vec<u8> {
 	aurora_engine_modexp::modexp(base, exponent, modulus)
 }
@@ -49,33 +47,13 @@ pub fn byzantium_gas_calc(base_len: u64, exp_len: u64, mod_len: u64, exp_highp:
 
 /// Calculate gas cost according to EIP 2565:
 /// <https://eips.ethereum.org/EIPS/eip-2565>
-#[allow(unused)]
 fn berlin_gas_calc(base_len: u64, exp_len: u64, mod_len: u64, exp_highp: &U256) -> u64 {
 	gas_calc::<200, 8, 3, _>(base_len, exp_len, mod_len, exp_highp, |max_len| -> U256 {
 		let words = U256::from(max_len.div_ceil(8));
 		words * words
 	})
 }
 
-/// Calculate gas cost according to EIP-7883:
-/// <https://eips.ethereum.org/EIPS/eip-7883>
-///
-/// There are three changes:
-/// 1. Increase minimal price from 200 to 500
-/// 2. Increase cost when exponent is larger than 32 bytes
-/// 3. Increase cost when base or modulus is larger than 32 bytes
-#[allow(unused)]
-fn osaka_gas_calc(base_len: u64, exp_len: u64, mod_len: u64, exp_highp: &U256) -> u64 {
-	gas_calc::<500, 16, 1, _>(base_len, exp_len, mod_len, exp_highp, |max_len| -> U256 {
-		if max_len <= 32 {
-			return U256::from(16); // multiplication_complexity = 16
-		}
-
-		let words = U256::from(max_len.div_ceil(8));
-		words * words * U256::from(2) // multiplication_complexity = 2 * words**2
-	})
-}
-
 /// Calculate gas cost.
 fn gas_calc<const MIN_PRICE: u64, const MULTIPLIER: u64, const GAS_DIVISOR: u64, F>(
 	base_len: u64,
@@ -162,63 +140,78 @@ pub fn left_pad_vec(data: &[u8], len: usize) -> Cow<'_, [u8]> {
 	}
 }
 
-impl<G: GasMutState> PurePrecompile<G> for Modexp {
-	fn execute(&self, input: &[u8], gasometer: &mut G) -> (ExitResult, Vec<u8>) {
-		// The format of input is:
-		// <length_of_BASE> <length_of_EXPONENT> <length_of_MODULUS> <BASE> <EXPONENT> <MODULUS>
-		// Where every length is a 32-byte left-padded integer representing the number of bytes
-		// to be taken up by the next value.
-		const HEADER_LENGTH: usize = 96;
-
-		// Extract the header
-		let base_len = U256::from_big_endian(&right_pad_with_offset::<32>(input, 0).into_owned());
-		let exp_len = U256::from_big_endian(&right_pad_with_offset::<32>(input, 32).into_owned());
-		let mod_len = U256::from_big_endian(&right_pad_with_offset::<32>(input, 64).into_owned());
-
-		// Cast base and modulus to usize, it does not make sense to handle larger values
-		let base_len = try_some!(usize::try_from(base_len).map_err(|_| ExitException::OutOfGas));
-		let mod_len = try_some!(usize::try_from(mod_len).map_err(|_| ExitException::OutOfGas));
-		// cast exp len to the max size, it will fail later in gas calculation if it is too large.
-		let exp_len = usize::try_from(exp_len).unwrap_or(usize::MAX);
-
-		// TODO: Check Osaka size limit.
-
-		// Used to extract ADJUSTED_EXPONENT_LENGTH.
-		let exp_highp_len = min(exp_len, 32);
-
-		// Throw away the header data as we already extracted lengths.
-		let input = input.get(HEADER_LENGTH..).unwrap_or_default();
-
-		let exp_highp = {
-			// Get right padded bytes so if data.len is less then exp_len we will get right padded zeroes.
-			let right_padded_highp = right_pad_with_offset::<32>(input, base_len);
-			// If exp_len is less then 32 bytes get only exp_len bytes and do left padding.
-			let out = left_pad::<32>(&right_padded_highp[..exp_highp_len]);
-			U256::from_big_endian(&out.into_owned())
-		};
-
-		// Check if we have enough gas.
-		let gas_cost =
-			byzantium_gas_calc(base_len as u64, exp_len as u64, mod_len as u64, &exp_highp);
-		try_some!(gasometer.record_gas(U256::from(gas_cost)));
-
-		if base_len == 0 && mod_len == 0 {
-			return (ExitSucceed::Returned.into(), Vec::new());
-		}
+fn execute<G: GasMutState>(
+	input: &[u8],
+	gasometer: &mut G,
+	gas_calc: fn(u64, u64, u64, &U256) -> u64,
+) -> (ExitResult, Vec<u8>) {
+	// The format of input is:
+	// <length_of_BASE> <length_of_EXPONENT> <length_of_MODULUS> <BASE> <EXPONENT> <MODULUS>
+	// Where every length is a 32-byte left-padded integer representing the number of bytes
+	// to be taken up by the next value.
+	const HEADER_LENGTH: usize = 96;
+
+	// Extract the header
+	let base_len = U256::from_big_endian(&right_pad_with_offset::<32>(input, 0).into_owned());
+	let exp_len = U256::from_big_endian(&right_pad_with_offset::<32>(input, 32).into_owned());
+	let mod_len = U256::from_big_endian(&right_pad_with_offset::<32>(input, 64).into_owned());
+
+	// Cast base and modulus to usize, it does not make sense to handle larger values
+	let base_len = try_some!(usize::try_from(base_len).map_err(|_| ExitException::OutOfGas));
+	let mod_len = try_some!(usize::try_from(mod_len).map_err(|_| ExitException::OutOfGas));
+	// cast exp len to the max size, it will fail later in gas calculation if it is too large.
+	let exp_len = usize::try_from(exp_len).unwrap_or(usize::MAX);
+
+	// Used to extract ADJUSTED_EXPONENT_LENGTH.
+	let exp_highp_len = min(exp_len, 32);
+
+	// Throw away the header data as we already extracted lengths.
+	let input = input.get(HEADER_LENGTH..).unwrap_or_default();
+
+	let exp_highp = {
+		// Get right padded bytes so if data.len is less then exp_len we will get right padded zeroes.
+		let right_padded_highp = right_pad_with_offset::<32>(input, base_len);
+		// If exp_len is less then 32 bytes get only exp_len bytes and do left padding.
+		let out = left_pad::<32>(&right_padded_highp[..exp_highp_len]);
+		U256::from_big_endian(&out.into_owned())
+	};
+
+	// Check if we have enough gas.
+	let gas_cost = gas_calc(base_len as u64, exp_len as u64, mod_len as u64, &exp_highp);
+	try_some!(gasometer.record_gas(U256::from(gas_cost)));
+
+	if base_len == 0 && mod_len == 0 {
+		return (ExitSucceed::Returned.into(), Vec::new());
+	}
+
+	// Padding is needed if the input does not contain all 3 values.
+	let input_len = base_len.saturating_add(exp_len).saturating_add(mod_len);
+	let input = right_pad_vec(input, input_len);
+	let (base, input) = input.split_at(base_len);
+	let (exponent, modulus) = input.split_at(exp_len);
+	debug_assert_eq!(modulus.len(), mod_len);
+
+	// Call the modexp.
+	let output = modexp(base, exponent, modulus);
+
+	(
+		ExitSucceed::Returned.into(),
+		left_pad_vec(&output, mod_len).into_owned(),
+	)
+}
 
-		// Padding is needed if the input does not contain all 3 values.
-		let input_len = base_len.saturating_add(exp_len).saturating_add(mod_len);
-		let input = right_pad_vec(input, input_len);
-		let (base, input) = input.split_at(base_len);
-		let (exponent, modulus) = input.split_at(exp_len);
-		debug_assert_eq!(modulus.len(), mod_len);
+pub struct ModexpByzantium;
 
-		// Call the modexp.
-		let output = modexp(base, exponent, modulus);
+impl<G: GasMutState> PurePrecompile<G> for ModexpByzantium {
+	fn execute(&self, input: &[u8], gasometer: &mut G) -> (ExitResult, Vec<u8>) {
+		execute(input, gasometer, byzantium_gas_calc)
+	}
+}
 
-		(
-			ExitSucceed::Returned.into(),
-			left_pad_vec(&output, mod_len).into_owned(),
-		)
+pub struct ModexpBerlin;
+
+impl<G: GasMutState> PurePrecompile<G> for ModexpBerlin {
+	fn execute(&self, input: &[u8], gasometer: &mut G) -> (ExitResult, Vec<u8>) {
+		execute(input, gasometer, berlin_gas_calc)
 	}
 }