Polkadot v1.1.0 upgrade

client/consensus/src/lib.rs

@@ -80,7 +80,7 @@ impl<Block: BlockT, I: Clone + BlockImport<Block>, C> Clone for FrontierBlockImp
 impl<B, I, C> FrontierBlockImport<B, I, C>
 where
 	B: BlockT,
-	I: BlockImport<B, Transaction = sp_api::TransactionFor<C, B>>,
+	I: BlockImport<B>,
 	I::Error: Into<ConsensusError>,
 	C: ProvideRuntimeApi<B>,
 	C::Api: BlockBuilderApi<B> + EthereumRuntimeRPCApi<B>,
@@ -98,13 +98,12 @@ where
 impl<B, I, C> BlockImport<B> for FrontierBlockImport<B, I, C>
 where
 	B: BlockT,
-	I: BlockImport<B, Transaction = sp_api::TransactionFor<C, B>> + Send + Sync,
+	I: BlockImport<B> + Send + Sync,
 	I::Error: Into<ConsensusError>,
 	C: ProvideRuntimeApi<B> + Send + Sync,
 	C::Api: BlockBuilderApi<B> + EthereumRuntimeRPCApi<B>,
 {
 	type Error = ConsensusError;
-	type Transaction = sp_api::TransactionFor<C, B>;
 
 	async fn check_block(
 		&mut self,
@@ -115,7 +114,7 @@ where
 
 	async fn import_block(
 		&mut self,
-		block: BlockImportParams<B, Self::Transaction>,
+		block: BlockImportParams<B>,
 	) -> Result<ImportResult, Self::Error> {
 		// We validate that there are only one frontier log. No other
 		// actions are needed and mapping syncing is delegated to a separate

client/rpc/src/eth/execute.rs

@@ -27,13 +27,12 @@ use sc_client_api::backend::{Backend, StorageProvider};
 use sc_transaction_pool::ChainApi;
 use sp_api::{
 	ApiExt, CallApiAt, CallApiAtParams, CallContext, Extensions, ProvideRuntimeApi,
-	StorageTransactionCache,
 };
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
 use sp_blockchain::HeaderBackend;
 use sp_inherents::CreateInherentDataProviders;
 use sp_io::hashing::{blake2_128, twox_128};
-use sp_runtime::{traits::Block as BlockT, DispatchError, SaturatedConversion};
+use sp_runtime::{traits::{Block as BlockT, HashingFor}, DispatchError, SaturatedConversion};
 use sp_state_machine::OverlayedChanges;
 // Frontier
 use fc_rpc_core::types::*;
@@ -241,14 +240,11 @@ where
 						api_version,
 						state_overrides,
 					)?;
-					let storage_transaction_cache =
-						RefCell::<StorageTransactionCache<B, C::StateBackend>>::default();
 					let params = CallApiAtParams {
 						at: substrate_hash,
 						function: "EthereumRuntimeRPCApi_call",
 						arguments: encoded_params,
 						overlayed_changes: &RefCell::new(overlayed_changes),
-						storage_transaction_cache: &storage_transaction_cache,
 						call_context: CallContext::Offchain,
 						recorder: &None,
 						extensions: &RefCell::new(Extensions::new()),
@@ -888,7 +884,7 @@ where
 		block_hash: B::Hash,
 		api_version: u32,
 		state_overrides: Option<BTreeMap<H160, CallStateOverride>>,
-	) -> RpcResult<OverlayedChanges> {
+	) -> RpcResult<OverlayedChanges<HashingFor<B>>> {
 		let mut overlayed_changes = OverlayedChanges::default();
 		if let Some(state_overrides) = state_overrides {
 			for (address, state_override) in state_overrides {

client/rpc/src/lib.rs

@@ -72,7 +72,7 @@ pub mod frontier_backend_client {
 	use sp_io::hashing::{blake2_128, twox_128};
 	use sp_runtime::{
 		generic::BlockId,
-		traits::{Block as BlockT, UniqueSaturatedInto, Zero},
+		traits::{Block as BlockT, UniqueSaturatedInto, Zero, HashingFor},
 	};
 	use sp_state_machine::OverlayedChanges;
 	// Frontier
@@ -95,7 +95,7 @@ pub mod frontier_backend_client {
 
 		fn set_overlayed_changes(
 			client: &C,
-			overlayed_changes: &mut OverlayedChanges,
+			overlayed_changes: &mut OverlayedChanges<HashingFor<B>>,
 			block: B::Hash,
 			_version: u32,
 			address: H160,
@@ -148,7 +148,7 @@ pub mod frontier_backend_client {
 
 		fn set_overlayed_changes(
 			client: &C,
-			overlayed_changes: &mut OverlayedChanges,
+			overlayed_changes: &mut OverlayedChanges<HashingFor<B>>,
 			block: B::Hash,
 			_version: u32,
 			address: H160,

frame/ethereum/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
+environmental = { workspace = true }
 ethereum = { workspace = true, features = ["with-codec"] }
 ethereum-types = { workspace = true }
 evm = { workspace = true, features = ["with-codec"] }
@@ -44,6 +45,7 @@ fp-self-contained = { workspace = true, features = ["default"] }
 [features]
 default = ["std"]
 std = [
+	"environmental/std",
 	"ethereum/std",
 	"evm/std",
 	"ethereum-types/std",

frame/ethereum/src/catch_exec_info.rs

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+// This file is part of Frontier.
+//
+// Copyright (c) 2020-2022 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use fp_evm::CallOrCreateInfo;
+
+environmental::environmental!(GLOBAL: Option<CallOrCreateInfo>);
+
+// Allow to catch informations of an ethereum execution inside the provided closure.
+pub fn catch_exec_info<R, F: FnOnce() -> R>(
+	execution_info: &mut Option<CallOrCreateInfo>,
+	f: F,
+) -> R {
+	GLOBAL::using(execution_info, f)
+}
+
+pub(super) fn fill_exec_info(execution_info: &CallOrCreateInfo) {
+	GLOBAL::with(|exec_info| exec_info.replace(execution_info.clone()));
+}

frame/ethereum/src/lib.rs

@@ -25,11 +25,14 @@
 #![allow(clippy::comparison_chain, clippy::large_enum_variant)]
 #![warn(unused_crate_dependencies)]
 
+mod catch_exec_info;
 #[cfg(all(feature = "std", test))]
 mod mock;
 #[cfg(all(feature = "std", test))]
 mod tests;
 
+pub use catch_exec_info::catch_exec_info;
+
 use ethereum_types::{Bloom, BloomInput, H160, H256, H64, U256};
 use evm::ExitReason;
 use fp_consensus::{PostLog, PreLog, FRONTIER_ENGINE_ID};
@@ -41,14 +44,14 @@ use fp_evm::{
 };
 use fp_storage::{EthereumStorageSchema, PALLET_ETHEREUM_SCHEMA};
 use frame_support::{
-	codec::{Decode, Encode, MaxEncodedLen},
 	dispatch::{DispatchInfo, DispatchResultWithPostInfo, Pays, PostDispatchInfo},
-	scale_info::TypeInfo,
+	pallet_prelude::TypeInfo,
 	traits::{EnsureOrigin, Get, PalletInfoAccess, Time},
 	weights::Weight,
 };
 use frame_system::{pallet_prelude::OriginFor, CheckWeight, WeightInfo};
 use pallet_evm::{BlockHashMapping, FeeCalculator, GasWeightMapping, Runner};
+use scale_codec::{Decode, Encode, MaxEncodedLen};
 use sp_runtime::{
 	generic::DigestItem,
 	traits::{DispatchInfoOf, Dispatchable, One, Saturating, UniqueSaturatedInto, Zero},
@@ -317,7 +320,7 @@ pub mod pallet {
 
 	/// Current building block's transactions and receipts.
 	#[pallet::storage]
-	pub(super) type Pending<T: Config> =
+	pub type Pending<T: Config> =
 		StorageValue<_, Vec<(Transaction, TransactionStatus, Receipt)>, ValueQuery>;
 
 	/// The current Ethereum block.
@@ -356,17 +359,14 @@ pub mod pallet {
 }
 
 impl<T: Config> Pallet<T> {
-	/// The call wrapped in the extrinsic is part of the PoV, record this as a base cost for the size of the proof.
-	fn proof_size_base_cost(transaction: &Transaction) -> u64 {
-		transaction
-			.encode()
-			.len()
-			// pallet index
-			.saturating_add(1)
-			// call index
-			.saturating_add(1) as u64
-	}
-
+		/// The call wrapped in the extrinsic is part of the PoV, record this as a base cost for the size of the proof.
+		fn proof_size_base_cost(transaction: &Transaction) -> u64 {
+			transaction
+				.encoded_size()
+				// pallet index + call index
+				.saturating_add(2) as u64
+		}
+
 	fn recover_signer(transaction: &Transaction) -> Option<H160> {
 		let mut sig = [0u8; 65];
 		let mut msg = [0u8; 32];
@@ -564,6 +564,8 @@ impl<T: Config> Pallet<T> {
 	) -> DispatchResultWithPostInfo {
 		let (to, _, info) = Self::execute(source, &transaction, None)?;
 
+		catch_exec_info::fill_exec_info(&info);
+
 		let pending = Pending::<T>::get();
 		let transaction_hash = transaction.hash();
 		let transaction_index = pending.len() as u32;
@@ -856,6 +858,24 @@ impl<T: Config> Pallet<T> {
 		}
 	}
 
+	/// Estimated maximal SCALE encoded size of an ethereum transaction
+	pub fn max_transaction_encoded_size(input: &[u8], access_list: &[(H160, Vec<H256>)]) -> u64 {
+		Self::proof_size_base_cost(&Transaction::EIP1559(ethereum::EIP1559Transaction{
+			chain_id: 0,
+			nonce: Default::default(),
+			max_priority_fee_per_gas: Default::default(),
+			max_fee_per_gas: Default::default(),
+			gas_limit: Default::default(),
+			action: ethereum::TransactionAction::Call(Default::default()),
+			value: Default::default(),
+			input: input.to_vec(),
+			access_list: access_list.iter().map(|(address, storage_keys)| AccessListItem { address: *address, storage_keys: storage_keys.to_vec() }).collect(),
+			odd_y_parity: false,
+			r: Default::default(),
+			s: Default::default(),
+		}))
+	}
+
 	/// Validate an Ethereum transaction already in block
 	///
 	/// This function must be called during the pre-dispatch phase

frame/ethereum/src/mock.rs

@@ -19,7 +19,6 @@
 
 use ethereum::{TransactionAction, TransactionSignature};
 use frame_support::{
-	dispatch::Dispatchable,
 	parameter_types,
 	traits::{ConstU32, FindAuthor},
 	weights::Weight,
@@ -131,13 +130,15 @@ impl FindAuthor<H160> for FindAuthorTruncated {
 
 const BLOCK_GAS_LIMIT: u64 = 150_000_000;
 const MAX_POV_SIZE: u64 = 5 * 1024 * 1024;
-
+/// The maximum storage growth per block in bytes.
+const MAX_STORAGE_GROWTH: u64 = 800 * 1024;
 parameter_types! {
 	pub const TransactionByteFee: u64 = 1;
 	pub const ChainId: u64 = 42;
 	pub const EVMModuleId: PalletId = PalletId(*b"py/evmpa");
 	pub BlockGasLimit: U256 = U256::from(BLOCK_GAS_LIMIT);
 	pub const GasLimitPovSizeRatio: u64 = BLOCK_GAS_LIMIT.saturating_div(MAX_POV_SIZE);
+	pub const GasLimitStorageGrowthRatio: u64 = BLOCK_GAS_LIMIT.saturating_div(MAX_STORAGE_GROWTH);
 	pub const WeightPerGas: Weight = Weight::from_parts(20_000, 0);
 }
 
@@ -169,6 +170,7 @@ impl pallet_evm::Config for Test {
 	type OnCreate = ();
 	type FindAuthor = FindAuthorTruncated;
 	type GasLimitPovSizeRatio = GasLimitPovSizeRatio;
+	type GasLimitStorageGrowthRatio = GasLimitStorageGrowthRatio;
 	type Timestamp = Timestamp;
 	type WeightInfo = ();
 }

frame/evm/Cargo.toml

@@ -46,7 +46,6 @@ std = [
 	"environmental?/std",
 	"evm/std",
 	"evm/with-serde",
-	"hex?/std",
 	"log/std",
 	"rlp?/std",
 	"scale-codec/std",

frame/evm/precompile/dispatch/Cargo.toml

@@ -13,6 +13,8 @@ frame-support = { workspace = true }
 # Frontier
 fp-evm = { workspace = true }
 pallet-evm = { workspace = true }
+sp-runtime = { workspace = true }
+scale-codec = { package = "parity-scale-codec", workspace = true }
 
 [dev-dependencies]
 scale-codec = { package = "parity-scale-codec", workspace = true }

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

@@ -27,14 +27,15 @@ mod mock;
 mod tests;
 
 use alloc::format;
+use scale_codec::{Decode, DecodeLimit};
+use sp_runtime::traits::Dispatchable;
 use core::marker::PhantomData;
 use fp_evm::{
 	ExitError, ExitSucceed, Precompile, PrecompileFailure, PrecompileHandle, PrecompileOutput,
 	PrecompileResult,
 };
 use frame_support::{
-	codec::{Decode, DecodeLimit as _},
-	dispatch::{DispatchClass, Dispatchable, GetDispatchInfo, Pays, PostDispatchInfo},
+	dispatch::{DispatchClass, GetDispatchInfo, Pays, PostDispatchInfo},
 	traits::{ConstU32, Get},
 };
 use pallet_evm::{AddressMapping, GasWeightMapping};
@@ -81,8 +82,11 @@ where
 			return Err(err);
 		}
 
-		handle
-			.record_external_cost(Some(info.weight.ref_time()), Some(info.weight.proof_size()))?;
+		handle.record_external_cost(
+			Some(info.weight.ref_time()),
+			Some(info.weight.proof_size()),
+			None,
+		)?;
 
 		match call.dispatch(Some(origin).into()) {
 			Ok(post_info) => {

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

@@ -153,6 +153,7 @@ impl pallet_evm::Config for Test {
 	type OnCreate = ();
 	type FindAuthor = FindAuthorTruncated;
 	type GasLimitPovSizeRatio = ();
+	type GasLimitStorageGrowthRatio = ();
 	type Timestamp = Timestamp;
 	type WeightInfo = ();
 }
@@ -183,6 +184,7 @@ impl PrecompileHandle for MockHandle {
 		&mut self,
 		_ref_time: Option<u64>,
 		_proof_size: Option<u64>,
+		_storage_growth: Option<u64>,
 	) -> Result<(), ExitError> {
 		Ok(())
 	}

frame/evm/src/benchmarking.rs

@@ -33,7 +33,7 @@ benchmarks! {
 
 		let x in 1..10000000;
 
-		use frame_benchmarking::vec;
+		use sp_std::vec;
 		use rlp::RlpStream;
 		use sp_core::{H160, U256};
 
@@ -71,7 +71,7 @@ benchmarks! {
 
 		let caller = "1000000000000000000000000000000000000001".parse::<H160>().unwrap();
 
-		let mut nonce: u64 = 1;
+		let mut nonce: u64 = 0;
 		let nonce_as_u256: U256 = nonce.into();
 
 		let value = U256::default();
@@ -83,8 +83,8 @@ benchmarks! {
 			contract_bytecode,
 			value,
 			gas_limit_create,
-			Some(U256::from(1_000_000_000)),
-			Some(U256::from(1_000_000_000)),
+			Some(U256::from(1_000_000_000_000_000u128)),
+			Some(U256::from(1_000_000_000_000_000u128)),
 			Some(nonce_as_u256),
 			Vec::new(),
 			is_transactional,
@@ -120,8 +120,8 @@ benchmarks! {
 			encoded_call,
 			value,
 			gas_limit_call,
-			Some(U256::from(1_000_000_000)),
-			Some(U256::from(1_000_000_000)),
+			Some(U256::from(1_000_000_000_000_000u128)),
+			Some(U256::from(1_000_000_000_000_000u128)),
 			Some(nonce_as_u256),
 			Vec::new(),
 			is_transactional,