Berlin support

Cargo.toml

@@ -18,7 +18,7 @@ rlp = { version = "0.5", default-features = false }
 primitive-types = { version = "0.10", default-features = false, features = ["rlp"] }
 serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 codec = { package = "parity-scale-codec", version = "2.0", default-features = false, features = ["derive"], optional = true }
-ethereum = { version = ">= 0.8, <= 0.9", default-features = false }
+ethereum = { version = "~0.8", default-features = false }
 environmental = { version = "1.1.2", default-features = false, optional = true }
 
 [dev-dependencies]

benches/loop.rs

@@ -53,6 +53,7 @@ fn run_loop_contract() {
 			.unwrap(),
 		// hex::decode("0f14a4060000000000000000000000000000000000000000000000000000000000002ee0").unwrap(),
 		u64::MAX,
+		Vec::new(),
 	);
 }
 

core/src/memory.rs

@@ -141,6 +141,15 @@ impl Memory {
 		len: U256,
 		data: &[u8],
 	) -> Result<(), ExitFatal> {
+		// Needed to pass ethereum test defined in
+		// https://github.com/ethereum/tests/commit/17f7e7a6c64bb878c1b6af9dc8371b46c133e46d
+		// (regardless of other inputs, a zero-length copy is defined to be a no-op).
+		// TODO: refactor `set` and `copy_large` (see
+		// https://github.com/rust-blockchain/evm/pull/40#discussion_r677180794)
+		if len.is_zero() {
+			return Ok(());
+		}
+
 		let memory_offset = if memory_offset > U256::from(usize::MAX) {
 			return Err(ExitFatal::NotSupported);
 		} else {

gasometer/src/costs.rs

@@ -39,10 +39,18 @@ pub fn sstore_refund(original: H256, current: H256, new: H256, config: &Config)
 				}
 
 				if original == new {
+					let (gas_sstore_reset, gas_sload) = if config.increase_state_access_gas {
+						(
+							config.gas_sstore_reset - config.gas_sload_cold,
+							config.gas_storage_read_warm,
+						)
+					} else {
+						(config.gas_sstore_reset, config.gas_sload)
+					};
 					if original == H256::default() {
-						refund += (config.gas_sstore_set - config.gas_sload) as i64;
+						refund += (config.gas_sstore_set - gas_sload) as i64;
 					} else {
-						refund += (config.gas_sstore_reset - config.gas_sload) as i64;
+						refund += (gas_sstore_reset - gas_sload) as i64;
 					}
 				}
 
@@ -122,11 +130,10 @@ pub fn verylowcopy_cost(len: U256) -> Result<u64, ExitError> {
 	Ok(gas.as_u64())
 }
 
-pub fn extcodecopy_cost(len: U256, config: &Config) -> Result<u64, ExitError> {
+pub fn extcodecopy_cost(len: U256, is_cold: bool, config: &Config) -> Result<u64, ExitError> {
 	let wordd = len / U256::from(32);
 	let wordr = len % U256::from(32);
-
-	let gas = U256::from(config.gas_ext_code)
+	let gas = U256::from(address_access_cost(is_cold, config.gas_ext_code, config))
 		.checked_add(
 			U256::from(G_COPY)
 				.checked_mul(if wordr == U256::zero() {
@@ -186,39 +193,71 @@ pub fn sha3_cost(len: U256) -> Result<u64, ExitError> {
 	Ok(gas.as_u64())
 }
 
+pub fn sload_cost(is_cold: bool, config: &Config) -> u64 {
+	if config.increase_state_access_gas {
+		if is_cold {
+			config.gas_sload_cold
+		} else {
+			config.gas_storage_read_warm
+		}
+	} else {
+		config.gas_sload
+	}
+}
+
+#[allow(clippy::collapsible_else_if)]
 pub fn sstore_cost(
 	original: H256,
 	current: H256,
 	new: H256,
 	gas: u64,
+	is_cold: bool,
 	config: &Config,
 ) -> Result<u64, ExitError> {
-	if config.sstore_gas_metering {
-		if config.sstore_revert_under_stipend && gas < config.call_stipend {
+	let (gas_sload, gas_sstore_reset) = if config.increase_state_access_gas {
+		(
+			config.gas_storage_read_warm,
+			config.gas_sstore_reset - config.gas_sload_cold,
+		)
+	} else {
+		(config.gas_sload, config.gas_sstore_reset)
+	};
+	let gas_cost = if config.sstore_gas_metering {
+		if config.sstore_revert_under_stipend && gas <= config.call_stipend {
 			return Err(ExitError::OutOfGas);
 		}
 
-		Ok(if new == current {
-			config.gas_sload
-		} else if original == current {
-			if original == H256::zero() {
-				config.gas_sstore_set
+		if new == current {
+			gas_sload
+		} else {
+			if original == current {
+				if original == H256::zero() {
+					config.gas_sstore_set
+				} else {
+					gas_sstore_reset
+				}
 			} else {
-				config.gas_sstore_reset
+				gas_sload
 			}
-		} else {
-			config.gas_sload
-		})
+		}
 	} else {
-		Ok(if current == H256::zero() && new != H256::zero() {
+		if current == H256::zero() && new != H256::zero() {
 			config.gas_sstore_set
 		} else {
-			config.gas_sstore_reset
-		})
-	}
+			gas_sstore_reset
+		}
+	};
+	Ok(
+		// In EIP-2929 we charge extra if the slot has not been used yet in this transaction
+		if is_cold {
+			gas_cost + config.gas_sload_cold
+		} else {
+			gas_cost
+		},
+	)
 }
 
-pub fn suicide_cost(value: U256, target_exists: bool, config: &Config) -> u64 {
+pub fn suicide_cost(value: U256, is_cold: bool, target_exists: bool, config: &Config) -> u64 {
 	let eip161 = !config.empty_considered_exists;
 	let should_charge_topup = if eip161 {
 		value != U256::zero() && !target_exists
@@ -232,22 +271,39 @@ pub fn suicide_cost(value: U256, target_exists: bool, config: &Config) -> u64 {
 		0
 	};
 
-	config.gas_suicide + suicide_gas_topup
+	let mut gas = config.gas_suicide + suicide_gas_topup;
+	if config.increase_state_access_gas && is_cold {
+		gas += config.gas_account_access_cold
+	}
+	gas
 }
 
 pub fn call_cost(
 	value: U256,
+	is_cold: bool,
 	is_call_or_callcode: bool,
 	is_call_or_staticcall: bool,
 	new_account: bool,
 	config: &Config,
 ) -> u64 {
 	let transfers_value = value != U256::default();
-	config.gas_call
+	address_access_cost(is_cold, config.gas_call, config)
 		+ xfer_cost(is_call_or_callcode, transfers_value)
 		+ new_cost(is_call_or_staticcall, new_account, transfers_value, config)
 }
 
+pub fn address_access_cost(is_cold: bool, regular_value: u64, config: &Config) -> u64 {
+	if config.increase_state_access_gas {
+		if is_cold {
+			config.gas_account_access_cold
+		} else {
+			config.gas_storage_read_warm
+		}
+	} else {
+		regular_value
+	}
+}
+
 fn xfer_cost(is_call_or_callcode: bool, transfers_value: bool) -> u64 {
 	if is_call_or_callcode && transfers_value {
 		G_CALLVALUE