EVM + Weight v2 support

frame/ethereum/Cargo.toml

@@ -81,3 +81,4 @@ try-runtime = [
 	"pallet-evm/try-runtime",
 ]
 forbid-evm-reentrancy = ["pallet-evm/forbid-evm-reentrancy"]
+evm-with-weight-limit = ["evm/with-substrate"]

frame/ethereum/src/lib.rs

@@ -151,6 +151,28 @@ where
 		len: usize,
 	) -> Option<TransactionValidity> {
 		if let Call::transact { transaction } = self {
+			// TODO Weight v2 type 16 bytes? check scale compact stuff
+			let encoded_len = transaction.encode().len() + 16usize;
+
+			// Validate submitted gas limit to weight conversion
+			let gas_limit = match transaction {
+				Transaction::Legacy(t) => t.gas_limit,
+				Transaction::EIP2930(t) => t.gas_limit,
+				Transaction::EIP1559(t) => t.gas_limit,
+			};
+			let without_base_extrinsic_weight = true;
+			let submitted_weight = T::GasWeightMapping::gas_to_weight(
+				gas_limit.unique_saturated_into(),
+				without_base_extrinsic_weight,
+				Some(encoded_len)
+			);
+			if submitted_weight != dispatch_info.weight {
+				return Some(Err(
+					TransactionValidityError::Invalid(InvalidTransaction::Custom(255))
+				));
+			}
+
+			// CheckWeight
 			if let Err(e) = CheckWeight::<T>::do_validate(dispatch_info, len) {
 				return Some(Err(e));
 			}
@@ -240,7 +262,7 @@ pub mod pallet {
 					Self::validate_transaction_in_block(source, &transaction).expect(
 						"pre-block transaction verification failed; the block cannot be built",
 					);
-					let r = Self::apply_validated_transaction(source, transaction)
+					let r = Self::apply_validated_transaction(source, transaction, None)
 						.expect("pre-block apply transaction failed; the block cannot be built");
 
 					weight = weight.saturating_add(r.actual_weight.unwrap_or_default());
@@ -276,7 +298,7 @@ pub mod pallet {
 			<T as pallet_evm::Config>::GasWeightMapping::gas_to_weight({
 				let transaction_data: TransactionData = transaction.into();
 				transaction_data.gas_limit.unique_saturated_into()
-			}, without_base_extrinsic_weight)
+			}, without_base_extrinsic_weight, None)
 		})]
 		pub fn transact(
 			origin: OriginFor<T>,
@@ -289,7 +311,25 @@ pub mod pallet {
 				"pre log already exists; block is invalid",
 			);
 
-			Self::apply_validated_transaction(source, transaction)
+			Self::apply_validated_transaction(source, transaction, None)
+		}
+
+		/// Transact an Ethereum transaction with native WeightV2+ limit.
+		#[pallet::call_index(1)]
+		#[pallet::weight({ *weight_limit })]
+		pub fn transact_with_weight_limit(
+			origin: OriginFor<T>,
+			transaction: Transaction,
+			weight_limit: Weight,
+		) -> DispatchResultWithPostInfo {
+			let source = ensure_ethereum_transaction(origin)?;
+			// Disable transact functionality if PreLog exist.
+			assert!(
+				fp_consensus::find_pre_log(&frame_system::Pallet::<T>::digest()).is_err(),
+				"pre log already exists; block is invalid",
+			);
+
+			Self::apply_validated_transaction(source, transaction, Some(weight_limit))
 		}
 	}
 
@@ -538,14 +578,15 @@ impl<T: Config> Pallet<T> {
 	fn apply_validated_transaction(
 		source: H160,
 		transaction: Transaction,
+		weight_limit: Option<Weight>,
 	) -> DispatchResultWithPostInfo {
-		let (to, _, info) = Self::execute(source, &transaction, None)?;
+		let (to, _, info) = Self::execute(source, &transaction, None, weight_limit)?;
 
 		let pending = Pending::<T>::get();
 		let transaction_hash = transaction.hash();
 		let transaction_index = pending.len() as u32;
 
-		let (reason, status, used_gas, dest) = match info {
+		let (reason, status, weight_info, used_gas, dest) = match info {
 			CallOrCreateInfo::Call(info) => (
 				info.exit_reason,
 				TransactionStatus {
@@ -561,6 +602,7 @@ impl<T: Config> Pallet<T> {
 						bloom
 					},
 				},
+				info.weight_info,
 				info.used_gas,
 				to,
 			),
@@ -579,6 +621,7 @@ impl<T: Config> Pallet<T> {
 						bloom
 					},
 				},
+				info.weight_info,
 				info.used_gas,
 				Some(info.value),
 			),
@@ -632,10 +675,19 @@ impl<T: Config> Pallet<T> {
 		});
 
 		Ok(PostDispatchInfo {
-			actual_weight: Some(T::GasWeightMapping::gas_to_weight(
-				used_gas.unique_saturated_into(),
-				true,
-			)),
+			actual_weight: {
+				let mut gas_to_weight = T::GasWeightMapping::gas_to_weight(
+					used_gas.unique_saturated_into(),
+					true,
+					None,
+				);
+				if let Some(weight_info) = weight_info {
+					if let Some(proof_size_usage) = weight_info.proof_size_usage {
+						*gas_to_weight.proof_size_mut() = proof_size_usage;
+					}
+				}
+				Some(gas_to_weight)
+			},
 			pays_fee: Pays::No,
 		})
 	}
@@ -650,6 +702,7 @@ impl<T: Config> Pallet<T> {
 		from: H160,
 		transaction: &Transaction,
 		config: Option<evm::Config>,
+		weight_limit: Option<Weight>,
 	) -> Result<
 		(Option<H160>, Option<H160>, CallOrCreateInfo),
 		DispatchErrorWithPostInfo<PostDispatchInfo>,
@@ -730,6 +783,7 @@ impl<T: Config> Pallet<T> {
 					access_list,
 					is_transactional,
 					validate,
+					weight_limit,
 					config.as_ref().unwrap_or_else(|| T::config()),
 				) {
 					Ok(res) => res,
@@ -758,6 +812,7 @@ impl<T: Config> Pallet<T> {
 					access_list,
 					is_transactional,
 					validate,
+					weight_limit,
 					config.as_ref().unwrap_or_else(|| T::config()),
 				) {
 					Ok(res) => res,
@@ -876,8 +931,8 @@ impl<T: Config> Pallet<T> {
 
 pub struct ValidatedTransaction<T>(PhantomData<T>);
 impl<T: Config> ValidatedTransactionT for ValidatedTransaction<T> {
-	fn apply(source: H160, transaction: Transaction) -> DispatchResultWithPostInfo {
-		Pallet::<T>::apply_validated_transaction(source, transaction)
+	fn apply(source: H160, transaction: Transaction, weight_limit: Option<Weight>) -> DispatchResultWithPostInfo {
+		Pallet::<T>::apply_validated_transaction(source, transaction, weight_limit)
 	}
 }
 

frame/evm/Cargo.toml

@@ -15,11 +15,13 @@ targets = ["x86_64-unknown-linux-gnu"]
 environmental = { workspace = true, optional = true }
 evm = { workspace = true, features = ["with-codec"] }
 hex = { version = "0.4.3", default-features = false, features = ["alloc"] }
+hex-literal = { version = "0.3.4" }
 impl-trait-for-tuples = "0.2.2"
 log = { workspace = true }
 rlp = { workspace = true }
 scale-codec = { package = "parity-scale-codec", workspace = true }
 scale-info = { workspace = true }
+sha3 = { version = "0.10", default-features = false }
 # Substrate
 frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
@@ -74,3 +76,4 @@ try-runtime = [
 	"pallet-timestamp/try-runtime",
 ]
 forbid-evm-reentrancy = ["dep:environmental"]
+evm-with-weight-limit = ["evm/with-substrate"]

frame/evm/precompile/blake2/Cargo.toml

@@ -20,3 +20,4 @@ std = [
 	# Frontier
 	"fp-evm/std",
 ]
+evm-with-weight-limit = ["pallet-evm-test-vector-support/evm-with-weight-limit"]

frame/evm/precompile/bn128/Cargo.toml

@@ -26,3 +26,4 @@ std = [
 	# Frontier
 	"fp-evm/std",
 ]
+evm-with-weight-limit = ["pallet-evm-test-vector-support/evm-with-weight-limit"]

frame/evm/precompile/dispatch/src/lib.rs

@@ -73,7 +73,7 @@ where
 
 		if let Some(gas) = target_gas {
 			let valid_weight =
-				info.weight.ref_time() <= T::GasWeightMapping::gas_to_weight(gas, false).ref_time();
+				info.weight.ref_time() <= T::GasWeightMapping::gas_to_weight(gas, false, None).ref_time();
 			if !valid_weight {
 				return Err(PrecompileFailure::Error {
 					exit_status: ExitError::OutOfGas,
@@ -83,13 +83,21 @@ where
 
 		let origin = T::AddressMapping::into_account_id(context.caller);
 
+		#[cfg(feature = "evm-with-weight-limit")]
+		handle.record_external_cost(
+			Some(info.weight.ref_time()),
+			Some(info.weight.proof_size()),
+		)?;
 		match call.dispatch(Some(origin).into()) {
 			Ok(post_info) => {
-				let cost = T::GasWeightMapping::weight_to_gas(
-					post_info.actual_weight.unwrap_or(info.weight),
-				);
-
+				let actual_weight = post_info.actual_weight.unwrap_or(info.weight);
+				let cost = T::GasWeightMapping::weight_to_gas(actual_weight);
 				handle.record_cost(cost)?;
+				#[cfg(feature = "evm-with-weight-limit")]
+				handle.refund_external_cost(
+					Some(info.weight.ref_time().saturating_sub(actual_weight.ref_time())),
+					Some(info.weight.proof_size().saturating_sub(actual_weight.proof_size())),
+				);
 
 				Ok(PrecompileOutput {
 					exit_status: ExitSucceed::Stopped,

frame/evm/precompile/dispatch/src/mock.rs

@@ -167,6 +167,9 @@ pub(crate) struct MockHandle {
 }
 
 impl PrecompileHandle for MockHandle {
+
+	type ExternalCost = ();
+
 	fn call(
 		&mut self,
 		_: H160,
@@ -183,6 +186,10 @@ impl PrecompileHandle for MockHandle {
 		Ok(())
 	}
 
+	fn record_external_cost(&mut self, _: Self::ExternalCost) -> Result<(), ExitError> {
+		Ok(())
+	}
+
 	fn remaining_gas(&self) -> u64 {
 		unimplemented!()
 	}

frame/evm/precompile/modexp/Cargo.toml

@@ -24,3 +24,4 @@ std = [
 	# Frontier
 	"fp-evm/std",
 ]
+evm-with-weight-limit = ["pallet-evm-test-vector-support/evm-with-weight-limit"]

frame/evm/precompile/simple/Cargo.toml

@@ -26,3 +26,4 @@ std = [
 	# Frontier
 	"fp-evm/std",
 ]
+evm-with-weight-limit = ["pallet-evm-test-vector-support/evm-with-weight-limit"]