Update evm and switch to shanghai hardfork

modules/asset-registry/src/mock.rs

@@ -201,7 +201,7 @@ pub fn deploy_contracts() {
 				H256::from_slice(&buf).as_bytes().to_vec()
 			},
 		}],
-		used_gas: 1235081,
+		used_gas: 1235455,
 		used_storage: 5131,
 	}));
 
@@ -242,7 +242,7 @@ pub fn deploy_contracts_same_prefix() {
 				H256::from_slice(&buf).as_bytes().to_vec()
 			},
 		}],
-		used_gas: 1235081,
+		used_gas: 1235455,
 		used_storage: 5131,
 	}));
 

modules/currencies/src/mock.rs

@@ -303,7 +303,7 @@ pub fn deploy_contracts() {
 				H256::from_slice(&buf).as_bytes().to_vec()
 			},
 		}],
-		used_gas: 1235081,
+		used_gas: 1235455,
 		used_storage: 5131,
 	}));
 

modules/evm-bridge/src/mock.rs

@@ -203,7 +203,7 @@ pub fn deploy_contracts() {
 				H256::from_slice(&buf).as_bytes().to_vec()
 			},
 		}],
-		used_gas: 1235081,
+		used_gas: 1235455,
 		used_storage: 5131,
 	}));
 
@@ -230,7 +230,7 @@ pub fn deploy_liquidation_ok_contracts() {
 		from: alice_evm_addr(),
 		contract: erc20_address(),
 		logs: vec![],
-		used_gas: 235274,
+		used_gas: 235330,
 		used_storage: 844,
 	}));
 
@@ -257,7 +257,7 @@ pub fn deploy_liquidation_err_contracts() {
 		from: alice_evm_addr(),
 		contract: erc20_address(),
 		logs: vec![],
-		used_gas: 228284,
+		used_gas: 228338,
 		used_storage: 818,
 	}));
 

modules/evm-utility/Cargo.toml

@@ -9,10 +9,10 @@ sha3 = { workspace = true }
 
 sp-std = { workspace = true }
 
-evm = { git = "https://github.com/rust-blockchain/evm", rev = "13240a8a551586fdef0b5028ed73af80b248092a", default-features = false, features = ["with-codec"] }
-evm-gasometer = { git = "https://github.com/rust-blockchain/evm", rev = "13240a8a551586fdef0b5028ed73af80b248092a", default-features = false }
-evm-runtime = { git = "https://github.com/rust-blockchain/evm", rev = "13240a8a551586fdef0b5028ed73af80b248092a", default-features = false }
-ethereum = { version = "0.14.0", default-features = false, features = ["with-codec"] }
+evm = { version = "0.41.1", default-features = false, features = ["with-codec"] }
+evm-gasometer = { version = "0.41.0", default-features = false }
+evm-runtime = { version = "0.41.0", default-features = false }
+ethereum = { version = "0.15.0", default-features = false, features = ["with-codec"] }
 
 [features]
 default = ["std"]

modules/evm/src/bench/mod.rs

@@ -80,7 +80,13 @@ fn whitelist_keys(b: &mut Bencher, from: H160, code: Vec<u8>) -> H160 {
 	let state = SubstrateStackState::<Runtime>::new(&vicinity, metadata);
 	let mut executor = StackExecutor::new_with_precompiles(state, config, &());
 
-	let mut runtime = EVMRuntime::new(Rc::new(code.clone()), Rc::new(Vec::new()), context, config);
+	let mut runtime = EVMRuntime::new(
+		Rc::new(code.clone()),
+		Rc::new(Vec::new()),
+		context,
+		config.stack_limit,
+		config.memory_limit,
+	);
 	let reason = executor.execute(&mut runtime);
 
 	assert!(reason.is_succeed(), "{:?}", reason);

modules/evm/src/lib.rs

@@ -24,7 +24,7 @@
 
 pub use crate::runner::{
 	stack::SubstrateStackState,
-	state::{PrecompileSet, StackExecutor, StackSubstateMetadata},
+	state::{PrecompileResult, StackExecutor, StackSubstateMetadata},
 	storage_meter::StorageMeter,
 	Runner,
 };
@@ -46,7 +46,11 @@ use frame_system::{ensure_root, ensure_signed, pallet_prelude::*, EnsureRoot, En
 use hex_literal::hex;
 pub use module_evm_utility::{
 	ethereum::{AccessListItem, Log, TransactionAction},
-	evm::{self, Config as EvmConfig, Context, ExitError, ExitFatal, ExitReason, ExitRevert, ExitSucceed},
+	evm::{
+		self,
+		executor::stack::{IsPrecompileResult, PrecompileFailure, PrecompileHandle, PrecompileOutput, PrecompileSet},
+		Config as EvmConfig, Context, ExitError, ExitFatal, ExitReason, ExitRevert, ExitSucceed, ExternalOperation,
+	},
 	Account,
 };
 pub use module_support::{
@@ -100,17 +104,17 @@ pub type NegativeImbalanceOf<T> =
 pub const RESERVE_ID_STORAGE_DEPOSIT: ReserveIdentifier = ReserveIdentifier::EvmStorageDeposit;
 pub const RESERVE_ID_DEVELOPER_DEPOSIT: ReserveIdentifier = ReserveIdentifier::EvmDeveloperDeposit;
 
-// Initially based on London hard fork configuration.
+// Initially based on shanghai hard fork configuration.
 static ACALA_CONFIG: EvmConfig = EvmConfig {
 	refund_sstore_clears: 0,            // no gas refund
 	sstore_gas_metering: false,         // no gas refund
 	sstore_revert_under_stipend: false, // ignored
 	create_contract_limit: Some(MaxCodeSize::get() as usize),
-	..module_evm_utility::evm::Config::london()
+	..module_evm_utility::evm::Config::shanghai()
 };
 
 /// Create an empty contract `contract Empty { }`.
-pub const BASE_CREATE_GAS: u64 = 67_066;
+pub const BASE_CREATE_GAS: u64 = 67_072;
 /// Call function that just set a storage `function store(uint256 num) public { number = num; }`.
 pub const BASE_CALL_GAS: u64 = 43_702;
 
@@ -410,8 +414,13 @@ pub mod module {
 					let state = SubstrateStackState::<T>::new(&vicinity, metadata);
 					let mut executor = StackExecutor::new_with_precompiles(state, T::config(), &());
 
-					let mut runtime =
-						evm::Runtime::new(Rc::new(account.code.clone()), Rc::new(Vec::new()), context, T::config());
+					let mut runtime = evm::Runtime::new(
+						Rc::new(account.code.clone()),
+						Rc::new(Vec::new()),
+						context,
+						T::config().stack_limit,
+						T::config().memory_limit,
+					);
 					let reason = executor.execute(&mut runtime);
 
 					assert!(

modules/evm/src/precompiles/blake2/mod.rs

@@ -17,8 +17,8 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use super::Precompile;
-use crate::runner::state::{PrecompileFailure, PrecompileOutput, PrecompileResult};
-use module_evm_utility::evm::{Context, ExitError, ExitSucceed};
+use crate::{PrecompileFailure, PrecompileHandle, PrecompileOutput, PrecompileResult};
+use module_evm_utility::evm::{ExitError, ExitSucceed};
 
 mod eip_152;
 
@@ -32,9 +32,10 @@ impl Precompile for Blake2F {
 	/// Format of `input`:
 	/// [4 bytes for rounds][64 bytes for h][128 bytes for m][8 bytes for t_0][8 bytes for t_1][1
 	/// byte for f]
-	fn execute(input: &[u8], target_gas: Option<u64>, _context: &Context, _is_static: bool) -> PrecompileResult {
+	fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
 		const BLAKE2_F_ARG_LEN: usize = 213;
 
+		let input = handle.input();
 		if input.len() != BLAKE2_F_ARG_LEN {
 			return Err(PrecompileFailure::Error {
 				exit_status: ExitError::Other(
@@ -48,13 +49,8 @@ impl Precompile for Blake2F {
 		let rounds: u32 = u32::from_be_bytes(rounds_buf);
 
 		let gas_cost: u64 = (rounds as u64) * Blake2F::GAS_COST_PER_ROUND;
-		if let Some(gas_left) = target_gas {
-			if gas_left < gas_cost {
-				return Err(PrecompileFailure::Error {
-					exit_status: ExitError::OutOfGas,
-				});
-			}
-		}
+		handle.record_cost(gas_cost)?;
+		let input = handle.input();
 
 		// we use from_le_bytes below to effectively swap byte order to LE if architecture is BE
 
@@ -107,17 +103,18 @@ impl Precompile for Blake2F {
 
 		Ok(PrecompileOutput {
 			exit_status: ExitSucceed::Returned,
-			cost: gas_cost,
 			output: output_buf.to_vec(),
-			logs: Default::default(),
 		})
 	}
 }
 
 #[cfg(test)]
 mod tests {
 	use super::*;
+	use crate::precompiles::tests::MockPrecompileHandle;
+	use frame_support::assert_ok;
 	use hex_literal::hex;
+	use module_evm_utility::evm::Context;
 	use sp_core::U256;
 
 	fn get_context() -> Context {
@@ -132,8 +129,10 @@ mod tests {
 	fn blake2f_cost() {
 		// 5 rounds
 		let input = hex!("0000000548c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
-		let result = Blake2F::execute(&input[..], None, &get_context(), false).unwrap();
-		assert_eq!(result.cost, 5);
+		let context = get_context();
+		let mut mock_handle = MockPrecompileHandle::new(&input[..], None, &context, false);
+		assert_ok!(Blake2F::execute(&mut mock_handle));
+		assert_eq!(mock_handle.gas_used, 5);
 	}
 
 	#[test]
@@ -144,15 +143,24 @@ mod tests {
 
 		// invalid input (too short)
 		let input = hex!("00");
-		assert_eq!(Blake2F::execute(&input[..], None, &get_context(), false), err);
+		assert_eq!(
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false)),
+			err
+		);
 
 		// Test vector 1 and expected output from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-152.md#test-vector-1
 		let input = hex!("00000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
-		assert_eq!(Blake2F::execute(&input[..], None, &get_context(), false), err);
+		assert_eq!(
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false)),
+			err
+		);
 
 		// Test vector 2 and expected output from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-152.md#test-vector-2
 		let input = hex!("000000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
-		assert_eq!(Blake2F::execute(&input[..], None, &get_context(), false), err);
+		assert_eq!(
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false)),
+			err
+		);
 	}
 
 	#[test]
@@ -163,7 +171,10 @@ mod tests {
 
 		// Test vector 3 and expected output from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-152.md#test-vector-3
 		let input = hex!("0000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000002");
-		assert_eq!(Blake2F::execute(&input[..], None, &get_context(), false), err);
+		assert_eq!(
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false)),
+			err
+		);
 	}
 
 	#[test]
@@ -172,7 +183,7 @@ mod tests {
 		let input = hex!("0000000048c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
 		let expected = hex!("08c9bcf367e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d282e6ad7f520e511f6c3e2b8c68059b9442be0454267ce079217e1319cde05b");
 		assert_eq!(
-			Blake2F::execute(&input[..], None, &get_context(), false)
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false))
 				.unwrap()
 				.output,
 			expected
@@ -185,7 +196,7 @@ mod tests {
 		let input = hex!("0000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
 		let expected = hex!("ba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923");
 		assert_eq!(
-			Blake2F::execute(&input[..], None, &get_context(), false)
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false))
 				.unwrap()
 				.output,
 			expected
@@ -198,7 +209,7 @@ mod tests {
 		let input = hex!("0000000c48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000");
 		let expected = hex!("75ab69d3190a562c51aef8d88f1c2775876944407270c42c9844252c26d2875298743e7f6d5ea2f2d3e8d226039cd31b4e426ac4f2d3d666a610c2116fde4735");
 		assert_eq!(
-			Blake2F::execute(&input[..], None, &get_context(), false)
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false))
 				.unwrap()
 				.output,
 			expected
@@ -211,7 +222,7 @@ mod tests {
 		let input = hex!("0000000148c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
 		let expected = hex!("b63a380cb2897d521994a85234ee2c181b5f844d2c624c002677e9703449d2fba551b3a8333bcdf5f2f7e08993d53923de3d64fcc68c034e717b9293fed7a421");
 		assert_eq!(
-			Blake2F::execute(&input[..], None, &get_context(), false)
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false))
 				.unwrap()
 				.output,
 			expected
@@ -226,7 +237,7 @@ mod tests {
 		let input = hex!("ffffffff48c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001");
 		let expected = hex!("fc59093aafa9ab43daae0e914c57635c5402d8e3d2130eb9b3cc181de7f0ecf9b22bf99a7815ce16419e200e01846e6b5df8cc7703041bbceb571de6631d2615");
 		assert_eq!(
-			Blake2F::execute(&input[..], None, &get_context(), false)
+			Blake2F::execute(&mut MockPrecompileHandle::new(&input[..], None, &get_context(), false))
 				.unwrap()
 				.output,
 			expected