EVM + Weight v2 support

.github/workflows/rust.yml

@@ -29,6 +29,8 @@ jobs:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
     - name: Run tests
       run: cargo test --locked --verbose --all
+    - name: Run tests (evm-with-weight-limit)
+      run: cargo test --locked --verbose --all --features evm-with-weight-limit
 
   integration:
     name: 'Run integration tests'
@@ -89,4 +91,4 @@ jobs:
     - name: Rustfmt
       run: cargo fmt --all -- --check
     - name: Clippy
-      run: cargo clippy --all --features runtime-benchmarks,try-runtime -- -D warnings
+      run: cargo clippy --all --features runtime-benchmarks,try-runtime,evm-with-weight-limit -- -D warnings

Cargo.toml

@@ -43,7 +43,7 @@ bn = { package = "substrate-bn", version = "0.6", default-features = false }
 environmental = { version = "1.1.4", default-features = false }
 ethereum = { version = "0.14.0", default-features = false }
 ethereum-types = { version = "0.14.1", default-features = false }
-evm = { version = "0.39.0", default-features = false }
+evm = { git = "https://github.com/purestake/evm", branch = "tgm-record-external-cost", default-features = false }
 hex-literal = { version = "0.3.4" }
 impl-serde = { version = "0.4.0", default-features = false }
 jsonrpsee = "0.16.2"

client/rpc/src/eth/execute.rs

@@ -569,7 +569,7 @@ where
 							.map_err(|err| internal_err(format!("execution fatal: {:?}", err)))?
 						};
 
-						(info.exit_reason, info.value, info.used_gas)
+						(info.exit_reason, info.value, info.used_gas.effective)
 					}
 					None => {
 						let info = if api_version == 1 {
@@ -627,7 +627,7 @@ where
 							.map_err(|err| internal_err(format!("execution fatal: {:?}", err)))?
 						};
 
-						(info.exit_reason, Vec::new(), info.used_gas)
+						(info.exit_reason, Vec::new(), info.used_gas.effective)
 					}
 				};
 				Ok(ExecutableResult {

frame/ethereum/Cargo.toml

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

frame/ethereum/src/lib.rs

@@ -353,6 +353,16 @@ pub mod pallet {
 }
 
 impl<T: Config> Pallet<T> {
+	fn transaction_len(transaction: &Transaction) -> u64 {
+		transaction
+			.encode()
+			.len()
+			// pallet index
+			.saturating_add(1)
+			// call index
+			.saturating_add(1) as u64
+	}
+
 	fn recover_signer(transaction: &Transaction) -> Option<H160> {
 		let mut sig = [0u8; 65];
 		let mut msg = [0u8; 32];
@@ -473,6 +483,17 @@ impl<T: Config> Pallet<T> {
 		let transaction_data: TransactionData = transaction.into();
 		let transaction_nonce = transaction_data.nonce;
 
+		let (weight_limit, proof_size_base_cost) =
+			match <T as pallet_evm::Config>::GasWeightMapping::gas_to_weight(
+				transaction_data.gas_limit.unique_saturated_into(),
+				true,
+			) {
+				weight_limit if weight_limit.proof_size() > 0 => {
+					(Some(weight_limit), Some(Self::transaction_len(transaction)))
+				}
+				_ => (None, None),
+			};
+
 		let (base_fee, _) = T::FeeCalculator::min_gas_price();
 		let (who, _) = pallet_evm::Pallet::<T>::account_basic(&origin);
 
@@ -485,6 +506,8 @@ impl<T: Config> Pallet<T> {
 				is_transactional: true,
 			},
 			transaction_data.clone().into(),
+			weight_limit,
+			proof_size_base_cost,
 		)
 		.validate_in_pool_for(&who)
 		.and_then(|v| v.with_chain_id())
@@ -540,7 +563,7 @@ impl<T: Config> Pallet<T> {
 		let transaction_hash = transaction.hash();
 		let transaction_index = pending.len() as u32;
 
-		let (reason, status, used_gas, dest, extra_data) = match info {
+		let (reason, status, weight_info, used_gas, dest, extra_data) = match info {
 			CallOrCreateInfo::Call(info) => (
 				info.exit_reason.clone(),
 				TransactionStatus {
@@ -556,6 +579,7 @@ impl<T: Config> Pallet<T> {
 						bloom
 					},
 				},
+				info.weight_info,
 				info.used_gas,
 				to,
 				match info.exit_reason {
@@ -599,6 +623,7 @@ impl<T: Config> Pallet<T> {
 						bloom
 					},
 				},
+				info.weight_info,
 				info.used_gas,
 				Some(info.value),
 				Vec::new(),
@@ -615,11 +640,11 @@ impl<T: Config> Pallet<T> {
 			let cumulative_gas_used = if let Some((_, _, receipt)) = pending.last() {
 				match receipt {
 					Receipt::Legacy(d) | Receipt::EIP2930(d) | Receipt::EIP1559(d) => {
-						d.used_gas.saturating_add(used_gas)
+						d.used_gas.saturating_add(used_gas.effective)
 					}
 				}
 			} else {
-				used_gas
+				used_gas.effective
 			};
 			match &transaction {
 				Transaction::Legacy(_) => Receipt::Legacy(ethereum::EIP658ReceiptData {
@@ -654,10 +679,18 @@ 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.standard.unique_saturated_into(),
+					true,
+				);
+				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,
 		})
 	}
@@ -738,6 +771,17 @@ impl<T: Config> Pallet<T> {
 
 		let is_transactional = true;
 		let validate = false;
+
+		let (transaction_len, weight_limit) =
+			match <T as pallet_evm::Config>::GasWeightMapping::gas_to_weight(
+				gas_limit.unique_saturated_into(),
+				true,
+			) {
+				weight_limit if weight_limit.proof_size() > 0 => {
+					(Some(Self::transaction_len(transaction)), Some(weight_limit))
+				}
+				_ => (None, None),
+			};
 		match action {
 			ethereum::TransactionAction::Call(target) => {
 				let res = match T::Runner::call(
@@ -752,6 +796,8 @@ impl<T: Config> Pallet<T> {
 					access_list,
 					is_transactional,
 					validate,
+					weight_limit,
+					transaction_len,
 					config.as_ref().unwrap_or_else(|| T::config()),
 				) {
 					Ok(res) => res,
@@ -780,6 +826,8 @@ impl<T: Config> Pallet<T> {
 					access_list,
 					is_transactional,
 					validate,
+					weight_limit,
+					transaction_len,
 					config.as_ref().unwrap_or_else(|| T::config()),
 				) {
 					Ok(res) => res,
@@ -812,6 +860,17 @@ impl<T: Config> Pallet<T> {
 		let (base_fee, _) = T::FeeCalculator::min_gas_price();
 		let (who, _) = pallet_evm::Pallet::<T>::account_basic(&origin);
 
+		let (weight_limit, proof_size_base_cost) =
+			match <T as pallet_evm::Config>::GasWeightMapping::gas_to_weight(
+				transaction_data.gas_limit.unique_saturated_into(),
+				true,
+			) {
+				weight_limit if weight_limit.proof_size() > 0 => {
+					(Some(weight_limit), Some(Self::transaction_len(transaction)))
+				}
+				_ => (None, None),
+			};
+
 		let _ = CheckEvmTransaction::<InvalidTransactionWrapper>::new(
 			CheckEvmTransactionConfig {
 				evm_config: T::config(),
@@ -821,6 +880,8 @@ impl<T: Config> Pallet<T> {
 				is_transactional: true,
 			},
 			transaction_data.into(),
+			weight_limit,
+			proof_size_base_cost,
 		)
 		.validate_in_block_for(&who)
 		.and_then(|v| v.with_chain_id())

frame/ethereum/src/mock.rs

@@ -134,11 +134,15 @@ impl FindAuthor<H160> for FindAuthorTruncated {
 	}
 }
 
+const BLOCK_GAS_LIMIT: u64 = 150_000_000;
+const MAX_POV_SIZE: u64 = 5 * 1024 * 1024;
+
 parameter_types! {
 	pub const TransactionByteFee: u64 = 1;
 	pub const ChainId: u64 = 42;
 	pub const EVMModuleId: PalletId = PalletId(*b"py/evmpa");
-	pub const BlockGasLimit: U256 = U256::MAX;
+	pub BlockGasLimit: U256 = U256::from(BLOCK_GAS_LIMIT);
+	pub const GasLimitPovSizeRatio: u64 = BLOCK_GAS_LIMIT.saturating_div(MAX_POV_SIZE);
 	pub const WeightPerGas: Weight = Weight::from_parts(20_000, 0);
 }
 
@@ -169,6 +173,7 @@ impl pallet_evm::Config for Test {
 	type OnChargeTransaction = ();
 	type OnCreate = ();
 	type FindAuthor = FindAuthorTruncated;
+	type GasLimitPovSizeRatio = GasLimitPovSizeRatio;
 	type Timestamp = Timestamp;
 	type WeightInfo = ();
 }

frame/ethereum/src/tests/eip1559.rs

@@ -335,7 +335,7 @@ fn transaction_should_generate_correct_gas_used() {
 
 		match info {
 			CallOrCreateInfo::Create(info) => {
-				assert_eq!(info.used_gas, expected_gas);
+				assert_eq!(info.used_gas.standard, expected_gas);
 			}
 			CallOrCreateInfo::Call(_) => panic!("expected create info"),
 		}
@@ -422,7 +422,7 @@ fn event_extra_data_should_be_handle_properly() {
 			input: hex::decode(TEST_CONTRACT_CODE).unwrap(),
 		}
 		.sign(&alice.private_key, None);
-		assert_ok!(Ethereum::apply_validated_transaction(alice.address, t));
+		assert_ok!(Ethereum::apply_validated_transaction(alice.address, t,));
 
 		let contract_address = hex::decode("32dcab0ef3fb2de2fce1d2e0799d36239671f04a").unwrap();
 		let foo = hex::decode("c2985578").unwrap();
@@ -440,7 +440,7 @@ fn event_extra_data_should_be_handle_properly() {
 		.sign(&alice.private_key, None);
 
 		// calling foo
-		assert_ok!(Ethereum::apply_validated_transaction(alice.address, t2));
+		assert_ok!(Ethereum::apply_validated_transaction(alice.address, t2,));
 		System::assert_last_event(RuntimeEvent::Ethereum(Event::Executed {
 			from: alice.address,
 			to: H160::from_slice(&contract_address),
@@ -464,7 +464,7 @@ fn event_extra_data_should_be_handle_properly() {
 		.sign(&alice.private_key, None);
 
 		// calling bar revert
-		assert_ok!(Ethereum::apply_validated_transaction(alice.address, t3));
+		assert_ok!(Ethereum::apply_validated_transaction(alice.address, t3,));
 		System::assert_last_event(RuntimeEvent::Ethereum(Event::Executed {
 			from: alice.address,
 			to: H160::from_slice(&contract_address),
@@ -553,3 +553,37 @@ fn validated_transaction_apply_zero_gas_price_works() {
 		assert_eq!(Balances::free_balance(&substrate_bob), 1_100);
 	});
 }
+
+#[cfg(feature = "evm-with-weight-limit")]
+#[test]
+fn proof_size_weight_limit_validation_works() {
+	let (pairs, mut ext) = new_test_ext(1);
+	let alice = &pairs[0];
+
+	ext.execute_with(|| {
+		let mut tx = EIP1559UnsignedTransaction {
+			nonce: U256::from(2),
+			max_priority_fee_per_gas: U256::zero(),
+			max_fee_per_gas: U256::from(1),
+			gas_limit: U256::from(0x100000),
+			action: ethereum::TransactionAction::Call(alice.address),
+			value: U256::from(1),
+			input: Vec::new(),
+		};
+
+		let gas_limit: u64 = 1_000_000;
+		tx.gas_limit = U256::from(gas_limit);
+
+		let weight_limit =
+			<Test as pallet_evm::Config>::GasWeightMapping::gas_to_weight(gas_limit, true);
+
+		// Gas limit cannot afford the extra byte and thus is expected to exhaust.
+		tx.input = vec![0u8; (weight_limit.proof_size() + 1) as usize];
+		let tx = tx.sign(&alice.private_key, None);
+
+		// Execute
+		assert!(
+			Ethereum::transact(RawOrigin::EthereumTransaction(alice.address).into(), tx,).is_err()
+		);
+	});
+}